时间戳

首页 > 技术文章 > 多线程（七）~join方法的使用

多线程（七）~join方法的使用

douJiangYouTiao888 2017-02-27 14:14 原文

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

    join()方法具有能使线程排队运行的作用，有点类似于同步的效果。
 
    join与synchronize的区别：
        join在内部使用wait()方法进行等待，底层用wait()来实现。
        synchronize关键字是以“对象监视器”为原理做同步操作。
 
    join()除了无参方法之外，还重载了join(毫秒)的方法，此方法与sleep(毫秒)的区别是：
        join()操作底层用wait()来实现，可以释放锁。
        sleep()不会释放锁。
 
join()释放锁的demo：
    线程类A：
  1. package com.wang.myjoin;
  3. publicclassThreadAextendsThread{
  5. privateThreadB threadB;
  7. publicThreadA(ThreadB threadB){
  8. this.threadB = threadB;
  9. }
  10. @Override
  11. publicvoid run(){
  12. synchronized(threadB){
  13. threadB.start();
  14. try{
  15. threadB.join();
  16. }catch(InterruptedException e1){
  17. e1.printStackTrace();
  18. }
  19. for(int i =0;i<10000;i++){
  20. System.out.println("b do sth....");
  21. }
  22. }
  23. }
  24. }
线程类B:
  1. package com.wang.myjoin;
  3. publicclassThreadBextendsThread{
  5. @Override
  6. publicvoid run(){
  7. System.out.println("B thread is run.");
  8. try{
  9. Thread.sleep(2000);
  10. }catch(InterruptedException e){
  11. e.printStackTrace();
  12. }
  13. System.out.println("B thread is over.");
  14. }
  16. publicsynchronizedvoid myService(){
  17. for(int i =0;i<100;i++){
  18. System.out.println("myService do sth."+ i);
  19. }
  20. }
  21. }
线程类C：
  1. package com.wang.myjoin;
  3. publicclassThreadCextendsThread{
  4. privateThreadB threadB;
  5. publicThreadC(ThreadB threadB){
  6. this.threadB = threadB;
  7. }
  8. @Override
  9. publicvoid run(){
  10. threadB.myService();
  11. }
  12. }
测试类：
  1. package com.wang.myjoin;
  3. publicclassJoinTest{
  4. publicstaticvoid main(String[] args){
  5. ThreadB threadB =newThreadB();
  6. ThreadA threadA =newThreadA(threadB);
  7. threadA.start();
  8. ThreadC threadC =newThreadC(threadB);
  9. threadC.start();
  10. System.out.println("~~~我来测试一下~~~~");
  11. }
  12. }
输出结果：
  1. B thread is run.
  2. ~~~我来测试一下~~~~
  3. myService do sth.0
  4. myService do sth.1
  5. myService do sth.2
  6. .
  7. .
  8. .
  9. myService do sth.99
  10. B thread is over.
  11. b do sth....
  12. b do sth....
  13. .
  14. .
  15. .
可见线程在join()之后是释放锁的，其他线程可以访问同锁的synchronize方法。
      
需要注意的问题：join()后的方法有可能会提前运行：(这个没试出来)
    我们同时执行以下三个操作：
    ①.thread1.start();
    ②.thread2.start();
    ③.sysout
    哪个先运行是不确定的，不过①和②的操作是相同的锁，所以是互斥的。



来自为知笔记(Wiz)



推荐阅读