多線程（七）~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)