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

作用：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)