多线程学习

 1 /**
 2  * 代码演示线程死锁 一个简单的死锁类
 3  * 
 4  * 当DeadLock类的对象flag==1时（lock1），先锁定o1,睡眠500毫秒
 5  * 
 6  * 而lock1在睡眠的时候另一个flag==0的对象（lock2）线程启动，先锁定o2,睡眠500毫秒
 7  * 
 8  * lock1睡眠结束后需要锁定o2才能继续执行，而此时o2已被lock2锁定；
 9  * 
10  * lock2睡眠结束后需要锁定o1才能继续执行，而此时o1已被lock1锁定；
11  * 
12  * lock1、lock2相互等待，都需要得到对方锁定的资源才能继续执行，从而死锁。
13  */
14 
15 public class TestDeadLock implements Runnable {
16     public int flag = 1;
17     static Object o1 = new Object(), o2 = new Object();
18 
19     @Override
20     public void run() {
21         System.out.println("flag=" + flag);
22         if (flag == 1) {
23             synchronized (o1) {
24                 try {
25                     Thread.sleep(1000);
26                 } catch (InterruptedException e) {
27                     // TODO Auto-generated catch block
28                     e.printStackTrace();
29                 }
30                 synchronized (o2) {
31                     System.out.println("1");
32                 }
33             }
34         }
35         if (flag == 0) {
36             synchronized (o2) {
37                 try {
38                     Thread.sleep(500);
39                 } catch (InterruptedException e) {
40                     // TODO Auto-generated catch block
41                     e.printStackTrace();
42                 }
43                 synchronized (o1) {
44                     System.out.println("0");
45                 }
46             }
47         }
48     }
49 
50     public static void main(String[] args) throws InterruptedException {
51         TestDeadLock lock1 = new TestDeadLock();
52         TestDeadLock lock2 = new TestDeadLock();
53 
54         lock1.flag = 1;
55         lock2.flag = 0;
56 
57         new Thread(lock1).start();
58         new Thread(lock2).start();
59     }
60 
61 }

 1 package tcl.o2o.it.threadinjdk5;
 2 
 3 import java.util.concurrent.CountDownLatch;
 4 import java.util.concurrent.ExecutorService;
 5 import java.util.concurrent.Executors;
 6 
 7 public class Learn03CountdownLatchTest {
 8 
 9     public static void main(String[] args) {
10         ExecutorService service = Executors.newCachedThreadPool(); // 创建一个线程池
11         final CountDownLatch cdOrder = new CountDownLatch(1);// 指挥官的命令，设置为1，指挥官一下达命令，则cutDown,变为0，战士们执行任务
12         final CountDownLatch cdAnswer = new CountDownLatch(3);// 因为有三个战士，所以初始值为3，每一个战士执行任务完毕则cutDown一次，当三个都执行完毕，变为0，则指挥官停止等待。
13         for (int i = 0; i < 3; i++) {
14             Runnable runnable = new Runnable() {
15                 public void run() {
16                     try {
17                         System.out.println("线程" + Thread.currentThread().getName() + "正准备接受命令");
18                         cdOrder.await(); // 战士们都处于等待命令状态
19                         System.out.println("线程" + Thread.currentThread().getName() + "已接受命令");
20                         Thread.sleep((long) (Math.random() * 10000));
21                         System.out.println("线程" + Thread.currentThread().getName() + "回应命令处理结果");
22                         cdAnswer.countDown(); // 任务执行完毕，返回给指挥官，cdAnswer减1。
23                     } catch (Exception e) {
24                         e.printStackTrace();    
25                     }
26                 }
27             };
28             service.execute(runnable);// 为线程池添加任务
29         }
30         try {
31             Thread.sleep((long) (Math.random() * 10000));
32 
33             System.out.println("线程" + Thread.currentThread().getName() + "即将发布命令");
34             cdOrder.countDown(); // 发送命令，cdOrder减1，处于等待的战士们停止等待转去执行任务。
35             System.out.println("线程" + Thread.currentThread().getName() + "已发送命令，正在等待结果");
36             cdAnswer.await(); // 命令发送后指挥官处于等待状态，一旦cdAnswer为0时停止等待继续往下执行
37             System.out.println("线程" + Thread.currentThread().getName() + "已收到所有响应结果");
38         } catch (Exception e) {
39             e.printStackTrace();
40         }
41         service.shutdown(); // 任务结束，停止线程池的所有线程
42 
43     }
44 }