让子线程中断主线程工作的2种办法

1.Thread.join

代码如下：

1. package demo;
3. import java.util.Random;
5. public class WaitAllSubThread {      
6.     
7. //    int liveThreadNum;//记录运行的子线程数    
8.     
9.     int n;  //工作线程数      
10.      
11.     public WaitAllSubThread(int n) {      
12.         this.n = n;      
13.     }      
14.      
15.     class Worker implements Runnable {      
16.      
17.         String name;      
18.         int sleep;      
19.      
20.         public Worker(String name, int sleep) {      
21.             this.name = name;      
22.             this.sleep = sleep;      
23.         }      
24.      
25.         public void run() {      
26.             
27. //          upLive(); //计算此线程已经工作.   
29.             System.out.println(name+", start to work.");      
30.             try {      
31.                 Thread.sleep(sleep);    //虚拟工作. 10s 随机时间      
32.             } catch (InterruptedException e) {      
33.                 System.out.println(name+" interrupted.");      
34.             }      
35.             System.out.println(name+", end to work ["+sleep+"] sleep.");      
36.             
37. //          downLive();   //此线程工作完成         
38.         }      
39.     }
40.     
41. //    //记录线程数的同步方法.    
42. //    private synchronized void downLive() {    
43. //        liveThreadNum--;    
44. //    }    
45. //   
46. //    private synchronized void upLive() {    
47. //        liveThreadNum++;    
48. //    }    
49. //   
50. //    private synchronized boolean isLive() {    
51. //        return liveThreadNum > 0;    
52. //    }   
53.      
54.     public void run() {  
55.         
56.         System.out.println("-------------main run start-------------");      
57.         int sleepSaid = 10 * 1000;  //每个工作线程虚拟工作最大时间      
58.         Random rm = new Random();
59.         
60.         Thread[] ths = new Thread[n];
61.         for(int i=0; i< ths.length; i++) {      
62.             ths[i] = new Thread(new Worker("worker-"+i, rm.nextInt(sleepSaid)+1));
63.             ths[i].start();      
64.         }      
65.      
66.         for(Thread th : ths) {      
67.             try {      
68.                 th.join();//join方式      
69.             } catch (InterruptedException e) {  
70.                 e.printStackTrace();      
71.             }      
72.         }      
73. //        //等待所有工作线程完成.    
74. //        while(isLive()) {    
75. //            try {    
76. //                Thread.sleep(1000); //每隔1s查看下是否所有线程完成.
77. //            } catch (InterruptedException e) {    
78. //                System.out.println("main thread sleep interrupted.");    
79. //            }    
80. //        }   
81.         System.out.println("---------------main run end--------------");      
82.     }      
83.      
84.     public static void main(String[] args) {      
85.         WaitAllSubThread wast = new WaitAllSubThread(10);      
86.         wast.run();      
87.     }      
88. }

2.CountDownLatch

代码如下：

1. package demo;
3. import java.util.Random;
4. import java.util.concurrent.CountDownLatch;
6. public class CountDownLatchUse {
7.     
8.     final CountDownLatch downLatch;      
9.     int n;  //工作线程数      
10.      
11.     public CountDownLatchUse(int n) {      
12.         this.downLatch = new CountDownLatch(n);      
13.         this.n = n;      
14.     }      
15.      
16.     class Worker implements Runnable {      
17.      
18.         String name;      
19.         int sleep;      
20.      
21.         public Worker(String name, int sleep) {      
22.             this.name = name;      
23.             this.sleep = sleep;      
24.         }      
25.      
26.         public void run() {      
27.             System.out.println(name+", start to work.");      
28.             try {      
29.                 Thread.sleep(sleep);    //虚拟工作. 10s 随机时间      
30.             } catch (InterruptedException e) {      
31.                 System.out.println(name+" interrupted.");      
32.             }      
33.             System.out.println(name+", end to work ["+sleep+"] sleep.");      
34.             meDone();   //某个工作线程完成      
35.         }      
36.     }      
37.      
38.     private void meDone() {      
39.         downLatch.countDown();      
40.     }      
41.      
42.     public void run() { 
43.         
44.         System.out.println("-------------main run start-------------");      
45.         int sleepSaid = 10 * 1000;  //每个工作线程虚拟工作最大时间      
46.         Random rm = new Random();      
47.         for(int i=0; i<n; i++) {      
48.             new Thread(new Worker("worker-"+i, rm.nextInt(sleepSaid)+1)).start();      
49.         }      
50.      
51.         try {      
52.             downLatch.await();  //等待所有工作线程完成.      
53.         } catch (InterruptedException e) {      
54.             System.out.println("main interrupted.");      
55.         }      
56.         System.out.println("---------------main run end--------------");      
57.     }      
58.      
59.     public static void main(String[] args) {     
60.         
61.         CountDownLatchUse mtu = new CountDownLatchUse(10);      
62.         mtu.run();
63.     }      
64. }