a

1. 
   
2. 
   
3. import java.util.concurrent.locks.Condition;
   
4. import java.util.concurrent.locks.Lock;
   
5. import java.util.concurrent.locks.ReentrantLock;
   
6. 
   
7. //第二题是  创建两个线程交替输出 1-10所有的数字
   
8. public class ThreadTest {
   
9.        
   
10.         private static int count = 0;
    
11.        
    
12.         private static Lock lock = new ReentrantLock();//新建一个锁对象
    
13.         private static Condition con = lock.newCondition();//获取一个 与锁绑定的condition对象
    
14.         private static boolean flag = false;//用于线程间通信
    
15.        
    
16.         //每调用一次函数输出count一次，输出后count加1
    
17.         public static void out() {// 多个线程或调用这个函数，所以需要就其进行同步
    
18.                 if (count <= 10) {
    
19.                         System.out
    
20.                                         .println(count++ + "..." + Thread.currentThread().getName());
    
21.                 }
    
22.         }
    
23. 
    
24.         public static void main(String[] args) throws Exception{
    
25.                 new Thread(new Runnable() {
    
26.                         public void run() {
    
27.                                 for (int i = 0; i < 5; i++) {//因为要输出10次，所以每个线程只需要调用5次 out()函数
    
28. //                                        synchronized(lock){
    
29.                                         lock.lock();//从这里锁定，只允许一个线程进入
    
30.                                                 while (flag)//内部类访问局部变量时，变量必须是常量，所以把flag定义在类里
    
31.                                                         try {
    
32. //                                                                lock.wait();
    
33.                                                                 con.await();
    
34.                                                         } catch (InterruptedException e) {
    
35.                                                                 e.printStackTrace();
    
36.                                                         }
    
37.                                                 out();
    
38.                                                 flag = true;
    
39. //                                                lock.notifyAll();
    
40.                                                 con.signalAll();
    
41.                                                 lock.unlock();//解锁
    
42.                                         }
    
43. //                                }
    
44.                         }
    
45.                 }).start();
    
46.                 new Thread(new Runnable() {
    
47.                         public void run() {
    
48.                                 for (int i = 0; i < 5; i++) {//因为要输出10次，所以每个线程只需要调用5次 out()函数
    
49. //                                        synchronized(lock){
    
50.                                         lock.lock();//从这里锁定，只允许一个线程进入
    
51.                                                 while (!flag)//内部类访问局部变量时，变量必须是常量，所以把flag定义在类里
    
52.                                                         try {
    
53. //                                                                lock.wait();
    
54.                                                                 con.await();
    
55.                                                         } catch (InterruptedException e) {
    
56.                                                                 e.printStackTrace();
    
57.                                                         }
    
58.                                                 out();
    
59.                                                 flag = false;
    
60. //                                                lock.notifyAll();
    
61.                                                 con.signalAll();
    
62.                                                 lock.unlock();//解锁
    
63.                                         }
    
64. //                                }
    
65.                         }
    
66.                 }).start();
    
67.         }
    
68. }
    

复制代码

a

1. 
   
2. 
   
3. import java.util.concurrent.locks.Condition;
   
4. import java.util.concurrent.locks.Lock;
   
5. import java.util.concurrent.locks.ReentrantLock;
   
6. 
   
7. //第二题是  创建两个线程交替输出 1-10所有的数字
   
8. public class ThreadTest {
   
9.        
   
10.         private static int count = 0;
    
11.        
    
12.         private static Lock lock = new ReentrantLock();//新建一个锁对象
    
13.         private static Condition con = lock.newCondition();//获取一个 与锁绑定的condition对象
    
14.         private static boolean flag = false;//用于线程间通信
    
15.        
    
16.         //每调用一次函数输出count一次，输出后count加1
    
17.         public static void out() {// 多个线程或调用这个函数，所以需要就其进行同步
    
18.                 if (count <= 10) {
    
19.                         System.out
    
20.                                         .println(count++ + "..." + Thread.currentThread().getName());
    
21.                 }
    
22.         }
    
23. 
    
24.         public static void main(String[] args) throws Exception{
    
25.                 new Thread(new Runnable() {
    
26.                         public void run() {
    
27.                                 for (int i = 0; i < 5; i++) {//因为要输出10次，所以每个线程只需要调用5次 out()函数
    
28. //                                        synchronized(lock){
    
29.                                         lock.lock();//从这里锁定，只允许一个线程进入
    
30.                                                 while (flag)//内部类访问局部变量时，变量必须是常量，所以把flag定义在类里
    
31.                                                         try {
    
32. //                                                                lock.wait();
    
33.                                                                 con.await();
    
34.                                                         } catch (InterruptedException e) {
    
35.                                                                 e.printStackTrace();
    
36.                                                         }
    
37.                                                 out();
    
38.                                                 flag = true;
    
39. //                                                lock.notifyAll();
    
40.                                                 con.signalAll();
    
41.                                                 lock.unlock();//解锁
    
42.                                         }
    
43. //                                }
    
44.                         }
    
45.                 }).start();
    
46.                 new Thread(new Runnable() {
    
47.                         public void run() {
    
48.                                 for (int i = 0; i < 5; i++) {//因为要输出10次，所以每个线程只需要调用5次 out()函数
    
49. //                                        synchronized(lock){
    
50.                                         lock.lock();//从这里锁定，只允许一个线程进入
    
51.                                                 while (!flag)//内部类访问局部变量时，变量必须是常量，所以把flag定义在类里
    
52.                                                         try {
    
53. //                                                                lock.wait();
    
54.                                                                 con.await();
    
55.                                                         } catch (InterruptedException e) {
    
56.                                                                 e.printStackTrace();
    
57.                                                         }
    
58.                                                 out();
    
59.                                                 flag = false;
    
60. //                                                lock.notifyAll();
    
61.                                                 con.signalAll();
    
62.                                                 lock.unlock();//解锁
    
63.                                         }
    
64. //                                }
    
65.                         }
    
66.                 }).start();
    
67.         }
    
68. }
    

复制代码