join  yield   的区别？

1. /*join()
   
2. join()方法使当前线程停下来等待，直至另一个调用join方法的线程终止。
   
3. 值得注意的是，线程的在被激活后不一定马上就运行，而是进入到可运行线程的队列中。
   
4. 但是join()可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException。
   
5. 使调用join()的线程执行完毕后才能执行其它线程，在一定意义上，它可以实现同步的功能。*/
   
6.     class TestThreadMethod extends Thread{
   
7.         public static int shareVar = 0;
   
8.         public TestThreadMethod(String name){
   
9.             super(name);
   
10.         }
    
11.         public void run(){
    
12.             for(int i=0; i<4; i++){
    
13.                 System.out.println(" " + i);
    
14.                 try{
    
15.                     Thread.sleep(3000);
    
16.                 }
    
17.                 catch(InterruptedException e){
    
18.                     System.out.println("Interrupted");
    
19.                 }
    
20.             }
    
21.         }
    
22.     }
    
23.     public class TestThread{
    
24.         public static void main(String[] args){
    
25.             TestThreadMethod t1 = new TestThreadMethod("t1");
    
26.             t1.start();
    
27.             try{
    
28.                 t1.join();
    
29.             }
    
30.             catch(InterruptedException e){}
    
31.             t1.start();
    
32.         }
    
33. }
    
34. 
    
35. 
    
36. /*yield()
    
37. Yield()方法是停止当前线程，让同等优先权的线程运行。
    
38. 如果没有同等优先权的线程，那么Yield()方法将不会起作用。
    
39. yield方法使当前线程让出CPU占有权，但让出的时间是不可设定的。
    
40. yield()也不会释放锁标志。实际上，yield()方法对应了如下操作；先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把CPU的占有权交给次线程，
    
41. 否则继续运行原来的线程，所以yield()方法称为“退让”，它把运行机会让给了同等级的其他线程。
    
42. yield()只是使当前线程重新回到可执行状态，所有执行yield()的线程有可能在进入到可执行状态后马上又被执行，所以yield()方法只能使同优先级的线程有执行的机会。*/
    
43. 
    
44. class TestThreadMethod extends Thread{
    
45.         public static int shareVar = 0;
    
46.         public TestThreadMethod(String name){
    
47.             super(name);
    
48.         }
    
49.         public synchronized void run(){
    
50.             for(int i=0; i<4; i++){
    
51.                 System.out.print(Thread.currentThread().getName());
    
52.                 System.out.println(" : " + i);
    
53.                 Thread.yield();
    
54.             }
    
55.         }
    
56.     }
    
57.     public class TestThread{
    
58.         public static void main(String[] args){
    
59.             TestThreadMethod t1 = new TestThreadMethod("t1");
    
60.             TestThreadMethod t2 = new TestThreadMethod("t2");
    
61.             t1.start();
    
62.             t1.start();　//（1）
    
63.             //t2.start();　（2）
    
64.         }
    
65. }
    
66. 
    
67. 从结果可知调用yield()时并不会释放对象的“锁标志”。

复制代码

yield() 方法：
yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。

join()方法:
线程A执行到了线程B的.join()方方法时，A就会等待，等B线程执行完，A才会执行。

join()

join()方法使调用该方法的线程在此之前执行完毕，也就是等待调用该方法的线程执行完毕后再往下继续执行。注意该方法也要捕获异常。

yield() 它与sleep()类似，只是不能由用户指定暂停多长时间，并且yield()方法只能让同优先级的线程有执行的机会

join方法是，用对象名称调用，在一个线程t2中调用另一个线程t1的join方法，线程t2会等待线程t1执行完后在执行

例：

1. public class Demo extends Thread {
   
2. public static void main(String[] args) {
   
3.    final Thread t1 = new Thread() {
   
4.     public void run() {
   
5.      for (int i = 0; i < 10; i++) {
   
6.       System.out.println("t1 ： " + i);
   
7.      }
   
8.     }
   
9.    };
   
10.    Thread t2 = new Thread() {
    
11.     public void run() {
    
12.      try {
    
13.       // 在另一方法里面只能调用final的局部变量,t1执行完后才会执行t2
    
14.       t1.join();
    
15.      } catch (InterruptedException e) {
    
16.       // TODO Auto-generated catch block
    
17.       e.printStackTrace();
    
18.      }
    
19.      for (int i = 0; i < 10; i++) {
    
20.       System.out.println("t2 ： " + i);
    
21.      }
    
22.     }
    
23.    };
    
24.    t1.start();
    
25.    t2.start();
    
26.    // 由于以下方法的线程级别高，所以会先执行
    
27.    System.out.println("demo exit");
    
28. }
    
29. }

复制代码

yield，相当与sleep()方法，只是没有指定休眠时间数，而且yield方法只让给相同级别的线程执行，如果没有相同级别的，线程继续运行，不退出。例：

1. public class Demo01 {
   
2. public static void main(String[] args) {
   
3.    Mythread mt = new Mythread("a");
   
4.    mt.start();
   
5.    Mythread mt2 = new Mythread("b");
   
6.    mt2.start();
   
7. }
   
8. }
   
9. class Mythread extends Thread {
   
10. 
    
11. public Mythread(String name) {
    
12.    super(name);
    
13. }
    
14. public void run() {
    
15.    for (int i = 0; i < 20; i++) {
    
16.     // 通过getId()方法，可以取到cpu为该线程分配的long类型的数字编号。程序员不能自己设置线程的id
    
17.     System.out.println(getName() + ":" + i + "---id:" + getId());
    
18.     // 通过类型调用yield()方法，可以使线程让步：
    
19.     Mythread.yield();
    
20.    }
    
21. }
    
22. }

复制代码