/ Java  

Java Multithreading 4: yield

This blog will introduce the yield() method in Thread. The content involved includes:

  1. Introduction to yield()
  2. yield() example
  3. Comparison of yield() and wait()

Introduction to yield()

The effect of yield() is to give in. It can make the current thread enter the runnable state from the running state, so that other waiting threads with the same priority can obtain execution rights. However, there is no guarantee that after the current thread calls yield(), others have the same priority will be able to obtain the execution right. It may also be that the current thread enters the running state and continues to run!

yield() example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class YieldDemo {
    public static void main(String[] args) {
        ThreadA t1 = new ThreadA("t1");
        ThreadA t2 = new ThreadA("t2");
        t1.start();
        t2.start();
    }

    static class ThreadA extends Thread {
        public ThreadA(String name) {
            super(name);
        }

        public synchronized void run() {
            for (int i = 0; i < 10; i++) {
                System.out.printf("%s [%d]:%d\n", this.getName(), this.getPriority(), i);

                if (i % 4 == 0)
                    Thread.yield();
            }
        }
    }
}

One of the possible result:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
t1 [5]:0
t2 [5]:0
t1 [5]:1
t1 [5]:2
t1 [5]:3
t1 [5]:4
t1 [5]:5
t1 [5]:6
t1 [5]:7
t1 [5]:8
t1 [5]:9
t2 [5]:1
t2 [5]:2
t2 [5]:3
t2 [5]:4
t2 [5]:5
t2 [5]:6
t2 [5]:7
t2 [5]:8
t2 [5]:9

t1 did not switch to t2 when it could be divided by 4. This shows that although yield() can make the thread enter the runnable state from the running state, it does not necessarily allow other threads to obtain CPU execution rights (that is, other threads enter the running state), even if other threads have the same priority as the thread currently calling yield().

Comparison of yield() and wait()

We know that wait() will let the current thread enter the blocked state (wait) from the running state, and also release the synchronization lock. yield() will also make the current thread leave the running state. The difference is:

  1. wait() will let the thread enter the blocked state (wait) from the running state, while yield() will let the thread enter the runnable state from the running state.
  2. wait() will release the synchronization lock of the object it holds, and the yield() method will not release the lock.
  3. yield() will give up the CPU execution time, rather than giving up the resource lock
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class YieldDemo2 {
    private static Object obj = new Object();

    public static void main(String[] args) {
        ThreadA t1 = new ThreadA("t1");
        ThreadA t2 = new ThreadA("t2");
        t1.start();
        t2.start();
    }

    static class ThreadA extends Thread {
        public ThreadA(String name) {
            super(name);
        }

        public void run() {
            synchronized (obj) {
                for (int i = 0; i < 10; i++) {
                    System.out.printf("%s [%d]:%d\n", this.getName(), this.getPriority(), i);

                    if (i % 4 == 0)
                        Thread.yield();
                }
            }
        }
    }
}

Results:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
t1 [5]:0
t1 [5]:1
t1 [5]:2
t1 [5]:3
t1 [5]:4
t1 [5]:5
t1 [5]:6
t1 [5]:7
t1 [5]:8
t1 [5]:9
t2 [5]:0
t2 [5]:1
t2 [5]:2
t2 [5]:3
t2 [5]:4
t2 [5]:5
t2 [5]:6
t2 [5]:7
t2 [5]:8
t2 [5]:9

The main thread started two threads t1 and t2. t1 and t2 will reference the synchronization lock of the same object in run(), namely synchronized(obj). While t1 is running, although it will call Thread.yield(), t2 will not get cpu execution rights. Because, t1 did not release the synchronous lock of obj!