来源于《Java多线程编程核心技术》

一、join() 作用

在很多情况，主线程创建并启动子线程，如果子线程中需要进行大量的耗时计算，主线程往往早于子线程结束。这时，如果主线程想等待子线程执行结束之后再结束，比如子线程处理一个数据，主线程要取得这个数据，就要用待jion() 方法。

方法join()的作用是等待线程对象的销毁

二、区别

　　sleep(long)方法在睡眠时不释放对象锁

　　join(long)方法在等待的过程中释放对象锁

三、实例

　　创建join_sleep_1项目

　　类ThreadA.java代码如下

 package extthread;

 public class ThreadA extends Thread {

     private ThreadB b;

     public ThreadA(ThreadB b) {

         super();

         this.b = b;

     }

     @Override

     public void run() {

         try {

             synchronized (b) {

                 b.start();

                 Thread.sleep(6000);

             }

         } catch (InterruptedException e) {

             e.printStackTrace();

         }

     }

 }

类ThreadB.java代码如下

 package extthread;

 public class ThreadB extends Thread {

     @Override

     public void run() {

         try {

             System.out.println("   b run begin timer="

                     + System.currentTimeMillis());

             Thread.sleep(5000);

             System.out.println("   b run   end timer="

                     + System.currentTimeMillis());

         } catch (InterruptedException e) {

             e.printStackTrace();

         }

     }

     synchronized public void bService() {

         System.out.println("��ӡ��bService timer=" + System.currentTimeMillis());

     }

 }

类ThreadC.java代码如

 package extthread;

 public class ThreadC extends Thread {

     private ThreadB threadB;

     public ThreadC(ThreadB threadB) {

         super();

         this.threadB = threadB;

     }

     @Override

     public void run() {

         threadB.bService();

     }

 }

Run.java 代码

 package test.run;

 import extthread.ThreadA;

 import extthread.ThreadB;

 import extthread.ThreadC;

 public class Run {

     public static void main(String[] args) {

         try {

             ThreadB b = new ThreadB();

             ThreadA a = new ThreadA(b);

             a.start();

             Thread.sleep(1000);

             ThreadC c = new ThreadC(b);

             c.start();

         } catch (InterruptedException e) {

             e.printStackTrace();

         }

     }

 }

结果

由于线程ThreadA使用Thread.sleep(long)方法一直持有ThreadB对象的锁，时间达到6秒，所以线程C只有在ThreadA时间到达6秒后释放ThreadB的锁时，才可以调用ThreadB中的同步方法Synchronized public void bService()

上面实验证明Thread.sleep(long)不释放锁

下面实验修改ThreadA.java

 package extthread;

 public class ThreadA extends Thread {

     private ThreadB b;

     public ThreadA(ThreadB b) {

         super();

         this.b = b;

     }

     @Override

     public void run() {

         try {

             synchronized (b) {

                 b.start();

                 b.join();

                 for (int i = 0; i < Integer.MAX_VALUE; i++) {

                     String newString = new String();

                     Math.random();

                 }

             }

         } catch (InterruptedException e) {

             e.printStackTrace();

         }

     }

 }

结果如下

由于线程ThreadA释放了ThreadB的锁，所以线程ThreadC可以调用ThreadB中的同步方法synchronized public void bService()

实验证明join(long)方法具有释放锁的特点

巴特西

join() 和 sleep() 区别

一、join() 作用

二、区别

三、实例

最新文章

热门文章