Java Thread类的 yield()、join()

版权声明：本文为"stone"原创文章，转载请注明出处 —— http://blog.csdn.net/jjwwmlp456。QQ交流群：473876194

yield：

解释它之前，先简述下，多线程的执行流程：多个线程并发请求执行时，由cpu决定优先执行哪一个，

即使通过thread.setPriority()，设置了线程的优先级，也不一定就是每次都先执行它

    yield，表示暂停当前线程，执行其他线程(包括自身线程) 由cpu决定

 

public class TestYield implements Runnable {

        public void run() {

                System.out.println("first: " + Thread.currentThread().getName() );
                // 暂停当前正在执行的线程对象，并执行其他线程，就是进入就绪状态
                Thread.currentThread().yield();
                // 可能还会执行 本线程: 以下语句不一定紧接着上面的语句被执行，可能其他线程的先执行了
                System.out.println("second: " + Thread.currentThread().getName() );

        }

        public static void main(String[] args) {
            TestYield runn = new TestYield();
            Thread t1 = new Thread(runn);
            Thread t2 = new Thread(runn);
            Thread t3 = new Thread(runn);

            t2.setPriority(t2.getPriority()+1); //设置t2的线程优先级
            t1.start();
            t2.start();
            t3.start();

        }
}

多次运行，看运行结果

 

某一次：

 

first: Thread-0
first: Thread-2
second: Thread-2
first: Thread-1
second: Thread-0
second: Thread-1

再一次：

 

 

first: Thread-1
first: Thread-2
first: Thread-0
second: Thread-2
second: Thread-1
second: Thread-0

其实默认情况下，多线程时，cpu就会切换执行的任务线程，而yield方法，只是人为的通知系统，进行切换，

 

且有一定机率能切换回本身

 

 

join：

 

阻塞所在线程，等调用它的线程执行完毕，再向下执行

 

public class TestJoin {

    public static void main(String[] args) throws InterruptedException {

        final Thread thread1 = new Thread() {
            public void run() {
                System.out.println("first");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("second");
            };
        };
        thread1.start();
//      thread1.join();     //在这阻塞主线程main

        Thread thread2 = new Thread() {
            public void run() {
                try {
                    System.out.println("third");
//                  thread1.join(); // 等待t1线程 执行完结，才继续向下执行  在这阻塞子线程thread2

                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("fourth");
            };
        };
        thread2.start();
    }
}

 

> 当没有打开相关的join调用代码时，『third、fourth』应该会优先于『second』进行输出

> 当仅打开主线程中的join调用代码时，则会阻塞主线程，thread2要等待thread1执行完后再执行，则会输出：

 

first
second
third
fourth

> 当仅打开thread2中的join调用代码时，则会阻塞thread2，则会输出：

 

 

first
third
second
fourth