java线程条件变量_Java线程：条件变量、原子量、线程池等

一、条件变量

条件变量实现了java.util.concurrent.locks.Condition接口，条件变量的实例化就是通过一个Lock对象上调用newCondition()方法获得的，这样条件就和一个锁绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。

条件变量的出现是为了更精细的控制线程等待与唤醒，一个锁可以有多个条件，每个条件上有多个线程等待，通过await()方法，可以让线程在该条件下等待。当调用signalAll()方法时，又可以唤醒该条件下等待的线程。条件变量比较抽象，原因是它不是自然语言中的条件概念，而是控制程序的一种手段。

看个例子，有一个账户，多个用户(线程)在同时操作这个账户，有的存款有的取款，存款随便存，但取款有限制，不能透支，任何试图透支的操作都将等待里面有足够的存款时才执行操作。

CaseTest.java

1 packageThread;2 import java.util.*;3 importjava.util.concurrent.ExecutorService;4 importjava.util.concurrent.Executors;5 importjava.util.concurrent.locks.Condition;6 importjava.util.concurrent.locks.Lock;7 importjava.util.concurrent.locks.ReentrantLock;8 public classCaseTest {9 public static voidmain(String[] args){10 MyCount1 myCount1=new MyCount1("6516431",10000);11 ExecutorService pool=Executors.newFixedThreadPool(2);12 Thread t1=new SaveThread("张三",myCount1,2000);13 Thread t2=new DrawThread("李四",myCount1,3600);14 Thread t3=new SaveThread("王二",myCount1,2700);15 Thread t4=new SaveThread("麻子",myCount1,600);16 Thread t5=new DrawThread("胖子",myCount1,1300);17 Thread t6=new DrawThread("小刘",myCount1,800);18 pool.execute(t1);19 pool.execute(t2);20 pool.execute(t3);21 pool.execute(t4);22 pool.execute(t5);23 pool.execute(t6);24 pool.shutdown();25 }26 }27 class SaveThread extendsThread{28 privateString name;29 privateMyCount1 myCount1;30 private intx;31 SaveThread(String name,MyCount1 myCount1,intx){32 this.name=name;33 this.myCount1=myCount1;34 this.x=x;35 }36 public voidrun(){37 myCount1.saving(x,name);38 }39 }40 class DrawThread extendsThread{41 privateString name;42 privateMyCount1 myCount;43 private intx;44 DrawThread(String name,MyCount1 myCount,intx){45 this.name=name;46 this.myCount=myCount;47 this.x=x;48 }49 public voidrun(){50 myCount.drawing(x,name);51 }52 }53 classMyCount1{54 privateString oid;55 private intcash;56 private Lock lock=newReentrantLock();57 private Condition _save=lock.newCondition();58 private Condition _draw=lock.newCondition();59 MyCount1(String oid,intcash){60 this.oid=oid;61 this.cash=cash;62 }63 public void saving(intx,String name){64 lock.lock(); //获取锁

65 if(x>0){66 cash+=x;67 System.out.println(name+"存款"+x+",当前余额为："+cash);68 }69 _draw.signalAll(); //唤醒所有等待线程。

70 lock.unlock(); //释放锁

71 }72 public void drawing(intx,String name){73 lock.lock();74 try{75 if(cash-x<0){76 _draw.await();//阻塞取款操作

77 }else{78 cash-=x;79 System.out.println(name+"取款"+x+",当前余额为："+cash);80 }81 _save.signalAll();//唤醒所有存款操作

82 }catch(InterruptedException e){83 e.printStackTrace();84 }finally{85 lock.unlock();86 }87 }88 }

View Code

结果为：

1 李四取款3600,当前余额为：6400

2 张三存款2000,当前余额为：8400

3 王二存款2700,当前余额为：11100

4 麻子存款600,当前余额为：11700

5 胖子取款1300,当前余额为：10400

6 小刘取款800,当前余额为：9600

View Code

如果不用条件变量和锁，如何实现此功能呢？

CaseTest.java

1 packageThread;2 import java.util.*;3 importjava.util.concurrent.ExecutorService;4 importjava.util.concurrent.Executors;5 importjava.util.concurrent.locks.Condition;6 importjava.util.concurrent.locks.Lock;7 importjava.util.concurrent.locks.ReentrantLock;8 public classCaseTest {9 public static voidmain(String[] args){10 MyCount1 myCount1=new MyCount1("6516431",10000);11 ExecutorService pool=Executors.newFixedThreadPool(2);12 Thread t1=new SaveThread("张三",myCount1,2000);13 Thread t2=new DrawThread("李四",myCount1,3600);14 Thread t3=new SaveThread("王二",myCount1,2700);15 Thread t4=new SaveThread("麻子",myCount1,600);16 Thread t5=new DrawThread("胖子",myCount1,1300);17 Thread t6=new DrawThread("小刘",myCount1,800);18 pool.execute(t1);19 pool.execute(t2);20 pool.execute(t3);21 pool.execute(t4);22 pool.execute(t5);23 pool.execute(t6);24 pool.shutdown();25 }26 }27 class SaveThread extendsThread{28 privateString name;29 privateMyCount1 myCount1;30 private intx;31 SaveThread(String name,MyCount1 myCount1,intx){32 this.name=name;33 this.myCount1=myCount1;34 this.x=x;35 }36 public voidrun(){37 myCount1.saving(x,name);38 }39 }40 class DrawThread extendsThread{41 privateString name;42 privateMyCount1 myCount;43 private intx;44 DrawThread(String name,MyCount1 myCount,intx){45 this.name=name;46 this.myCount=myCount;47 this.x=x;48 }49 public voidrun(){50 myCount.drawing(x,name);51 }52 }53 classMyCount1{54 privateString oid;55 private intcash;56 MyCount1(String oid,intcash){57 this.oid=oid;58 this.cash=cash;59 }60 public synchronized void saving(intx,String name){61 if(x>0){62 cash+=x;63 System.out.println(name+"存款"+x+",当前余额为："+cash);64 }65 notifyAll();66 //_draw.signalAll();//唤醒所有等待线程。67 //lock.unlock();//释放锁

68 }69 public synchronized void drawing(intx,String name){70 if(cash-x<0){71 try{72 wait();73 }74 catch(InterruptedException e){75 e.printStackTrace();76 }77 }else{78 cash-=x;79 System.out.println(name+"取款"+x+",当前余额为："+cash);80 }81 notifyAll();82

83 }84 }

View Code

第二种方式是用同步方法的第一种方法，以前说过这种方法不如第二种好，下面改进一下该同步的程序：

CaseTest.java

1 packageThread;2 import java.util.*;3 importjava.util.concurrent.ExecutorService;4 importjava.util.concurrent.Executors;5 importjava.util.concurrent.locks.Condition;6 importjava.util.concurrent.locks.Lock;7 importjava.util.concurrent.locks.ReentrantLock;8 public classCaseTest {9 public static voidmain(String[] args){10 MyCount1 myCount1=new MyCount1("6516431",10000);11 ExecutorService pool=Executors.newFixedThreadPool(2);12 Thread t1=new SaveThread("张三",myCount1,2000);13 Thread t2=new DrawThread("李四",myCount1,3600);14 Thread t3=new SaveThread("王二",myCount1,2700);15 Thread t4=new SaveThread("麻子",myCount1,600);16 Thread t5=new DrawThread("胖子",myCount1,1300);17 Thread t6=new DrawThread("小刘",myCount1,800);18 pool.execute(t1);19 pool.execute(t2);20 pool.execute(t3);21 pool.execute(t4);22 pool.execute(t5);23 pool.execute(t6);24 pool.shutdown();25 }26 }27 class SaveThread extendsThread{28 privateString name;29 privateMyCount1 myCount1;30 private intx;31 SaveThread(String name,MyCount1 myCount1,intx){32 this.name=name;33 this.myCount1=myCount1;34 this.x=x;35 }36 public voidrun(){37 myCount1.saving(x,name);38 }39 }40 class DrawThread extendsThread{41 privateString name;42 privateMyCount1 myCount;43 private intx;44 DrawThread(String name,MyCount1 myCount,intx){45 this.name=name;46 this.myCount=myCount;47 this.x=x;48 }49 public voidrun(){50 myCount.drawing(x,name);51 }52 }53 classMyCount1{54 privateString oid;55 private intcash;56 //private Lock lock=new ReentrantLock();57 //private Condition _save=lock.newCondition();58 //private Condition _draw=lock.newCondition();

59 MyCount1(String oid,intcash){60 this.oid=oid;61 this.cash=cash;62 }63 public void saving(intx,String name){64 synchronized(this){65 if(x>0){66 cash+=x;67 System.out.println(name+"存款"+x+",当前余额为："+cash);68 }69 notifyAll();70 }71 }72 public void drawing(intx,String name){73 synchronized(this){74 if(cash-x<0){75 try{76 wait();77 }78 catch(InterruptedException e){79 e.printStackTrace();80 }81 }else{82 cash-=x;83 System.out.println(name+"取款"+x+",当前余额为："+cash);84 }85 notifyAll();86 }87 }88 }

View Code

二、Volatile变量

三、原子量

所谓原子量就是操作变量的操作是“原子的”，该操作不可再分，因此线程是安全的。volatile、synchronized关键字来解决并发访问的安全问题，但这样太麻烦。有一个用来进行单变量多线程并发安全访问的工具包java.util.concurrent.atmoic。

Test.java

1 packageThread;2 importjava.util.concurrent.ExecutorService;3 importjava.util.concurrent.Executors;4 importjava.util.concurrent.atomic.AtomicLong;5 public classCaseTest {6 public static voidmain(String[] args){7 ExecutorService pool=Executors.newFixedThreadPool(2);8 Runnable t1=new MyRunnable_2("张三",2000);9 Runnable t2=new MyRunnable_2("李四",3600);10 Runnable t3=new MyRunnable_2("王二",2700);11 Runnable t4=new MyRunnable_2("麻子",600);12 Runnable t5=new MyRunnable_2("胖子",1300);13 Runnable t6=new MyRunnable_2("小刘",800);14 pool.execute(t1);15 pool.execute(t2);16 pool.execute(t3);17 pool.execute(t4);18 pool.execute(t5);19 pool.execute(t6);20 pool.shutdown();21 }22 }23 class MyRunnable_2 implementsRunnable{24 private static AtomicLong aLong = new AtomicLong(10000);25 privateString name;26 private intx;27 MyRunnable_2(String name,intx){28 this.name=name;29 this.x=x;30 }31 public voidrun(){32 System.out.println(name+"执行了"+x+",余额为："+aLong.addAndGet(x));33 }34 }

View Code

结果为

1 /**第一种结果**/

2 张三执行了2000,余额为：12000

3 王二执行了2700,余额为：14700

4 麻子执行了600,余额为：15300

5 胖子执行了1300,余额为：16600

6 小刘执行了800,余额为：17400

7 李四执行了3600,余额为：21000

8

9 /**第二种结果**/

10 张三执行了2000,余额为：15600

11 李四执行了3600,余额为：13600

12 王二执行了2700,余额为：18300

13 麻子执行了600,余额为：18900

14 胖子执行了1300,余额为：20200

15 小刘执行了800,余额为：21000

View Code

这个例子是个反例，可见到虽然使用了原子量，但是并发访问还是有问题，那么问题在哪？原子量虽然可以保证单个变量在某一个操作过程安全，但无法保证整个代码块，或者说整个程序的安全。因此，通常可以使用锁等同步机制控制整个程序的安全性。

Test.java

1 packageThread;2 importjava.util.concurrent.ExecutorService;3 importjava.util.concurrent.Executors;4 importjava.util.concurrent.atomic.AtomicLong;5 importjava.util.concurrent.locks.Lock;6 importjava.util.concurrent.locks.ReentrantLock;7 public classCaseTest {8 public static voidmain(String[] args){9 ExecutorService pool=Executors.newFixedThreadPool(2);10 Lock lock=new ReentrantLock(false);11 Runnable t1=new MyRunnable_2("张三",2000,lock);12 Runnable t2=new MyRunnable_2("李四",3600,lock);13 Runnable t3=new MyRunnable_2("王二",2700,lock);14 Runnable t4=new MyRunnable_2("麻子",600,lock);15 Runnable t5=new MyRunnable_2("胖子",1300,lock);16 Runnable t6=new MyRunnable_2("小刘",800,lock);17 pool.execute(t1);18 pool.execute(t2);19 pool.execute(t3);20 pool.execute(t4);21 pool.execute(t5);22 pool.execute(t6);23 pool.shutdown();24 }25 }26 class MyRunnable_2 implementsRunnable{27 private static AtomicLong aLong = new AtomicLong(10000);28 privateString name;29 private intx;30 privateLock lock;31 MyRunnable_2(String name,intx,Lock lock){32 this.name=name;33 this.x=x;34 this.lock=lock;35 }36 public voidrun(){37 lock.lock();38 System.out.println(name+"执行了"+x+",余额为："+aLong.addAndGet(x));39 lock.unlock();40 }41 }

View Code

结果为：

1 张三执行了2000,余额为：12000

2 李四执行了3600,余额为：15600

3 王二执行了2700,余额为：18300

4 胖子执行了1300,余额为：19600

5 麻子执行了600,余额为：20200

6 小刘执行了800,余额为：21000

View Code

此时，加入了一个对象锁，来控制并发访问的控制，不管程序运行多少次，结果都是一样的。有关原子的用法仅仅保证变量操作的原子性，但是需要考虑整个过程的线程安全性。

四、信号量

一个信号量管理很多的许可证，为了获取信号量，线程通过调用acquire请求许可。Java信号量实际上是一个功能完毕的计数器，并由此限制了通过的线程数量，其他线程可以通过调用release释放许可。

它对控制一定资源的消费与回收有着重要意义，信号量常常用于多线程的代码中，并能监控有多少数目的线程等待获取资源，并且通过信号量可以得知可用资源的数目等等，这里强调数目二字，并不是指有哪些在等待，哪些资源可用。例子：

SignalTest.java

1 packageThread;2

3 importjava.util.concurrent.ExecutorService;4 importjava.util.concurrent.Executors;5 importjava.util.concurrent.Semaphore;6

7 public classSignalTest {8 public static voidmain(String[] args){9 MyPool myPool=new MyPool(20);10 ExecutorService threadPool=Executors.newFixedThreadPool(2);11 MyThread_signal t1=new MyThread_signal("任务A",myPool,3);12 MyThread_signal t2=new MyThread_signal("任务B",myPool,12);13 MyThread_signal t3=new MyThread_signal("任务C",myPool,7);14 threadPool.execute(t1);15 threadPool.execute(t2);16 threadPool.execute(t3);17 threadPool.shutdown();18 }19 }20 classMyPool{21 private Semaphore sp;//池相关的信号量

22 MyPool(int size){this.sp=newSemaphore(size);}23 public Semaphore getSp(){returnsp;}24 public void setSp(Semaphore sp){this.sp=sp;}25 }26 class MyThread_signal extendsThread{27 privateString name;28 privateMyPool myPool;29 private intx;30 MyThread_signal(String name,MyPool myPool,intx){31 this.name=name;32 this.myPool=myPool;33 this.x=x;34 }35 public voidrun(){36 try{37 myPool.getSp().acquire();38 System.out.println(name+"成功获取了"+x+"个许可！");39 }40 catch(InterruptedException e){e.printStackTrace();}41 finally{myPool.getSp().release(x);42 System.out.println(name+"释放了"+x+"个许可！");}43 }44 }

View Code

结果为：

1 任务A成功获取了3个许可！2 任务A释放了3个许可！3 任务C成功获取了7个许可！4 任务C释放了7个许可！5 任务B成功获取了12个许可！6 任务B释放了12个许可！

View Code

信号量仅仅是对池资源进行监控，但不能 保证线程的安全，因此，应该自己控制线程的安全访问资源。

五、线程池

线程池的思想还是一种对象池的思想，开辟一块内存空间，里面存放众多的(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完线程对象归池，这样可以避免反复创建线程对象带来的性能开销，节约系统资源。

线程池分为固定尺寸的线程池、可变尺寸线程池。

1、固定大小的线程池

1 packageThread;2

3 importjava.util.concurrent.ExecutorService;4 importjava.util.concurrent.Executors;5

6 public classTest1 {7 public static voidmain(String[] args){8 ExecutorService pool=Executors.newFixedThreadPool(2);9 Thread t1=newMyThread_test();10 Thread t2=newMyThread_test();11 Thread t3=newMyThread_test();12 Thread t4=newMyThread_test();13 pool.execute(t1);14 pool.execute(t2);15 pool.execute(t3);16 pool.execute(t4);17 pool.shutdown();18 }19 }20 class MyThread_test extendsThread{21 public voidrun(){22 System.out.println(Thread.currentThread().getName()+"正在执行。。");23 }24 }

View Code

1 pool-1-thread-1正在执行。。2 pool-1-thread-2正在执行。。3 pool-1-thread-1正在执行。。4 pool-1-thread-2正在执行。。

View Code

2、单任务线程池

在上一例修改一行pool对象的代码为：

1 ExecutorService pool=Executors.newSingleThreadExecutor();

1 pool-1-thread-1正在执行。。2 pool-1-thread-1正在执行。。3 pool-1-thread-1正在执行。。4 pool-1-thread-1正在执行。。

以上两种情况都是大小固定的，当要加入的池的线程(或任务)超过池最大尺寸的时候，则入此线程池需要排队等待。

3、可变尺寸的线程池

1 ExecutorService pool=Executors.newCachedThreadPool();

pool-1-thread-1正在执行。。

pool-1-thread-4正在执行。。

pool-1-thread-3正在执行。。

pool-1-thread-2正在执行。。

4、延迟线程池

1 packageThread;2

3 importjava.util.concurrent.ExecutorService;4 importjava.util.concurrent.Executors;5 importjava.util.concurrent.ScheduledExecutorService;6 importjava.util.concurrent.TimeUnit;7

8 public classTest1 {9 public static voidmain(String[] args){10 //ExecutorService pool=Executors.newFixedThreadPool(2);11 //ExecutorService pool=Executors.newSingleThreadExecutor();12 //ExecutorService pool=Executors.newCachedThreadPool();

13 ScheduledExecutorService pool=Executors.newScheduledThreadPool(2);14 Thread t1=newMyThread_test();15 Thread t2=newMyThread_test();16 Thread t3=newMyThread_test();17 Thread t4=newMyThread_test();18 Thread t5=newMyThread_test();19 Thread t6=newMyThread_test();20 pool.execute(t1);21 pool.execute(t2);22 pool.execute(t3);23 pool.execute(t4);24 pool.schedule(t5,10,TimeUnit.MILLISECONDS);25 pool.schedule(t6,10,TimeUnit.MILLISECONDS);26 pool.shutdown();27 }28 }29 class MyThread_test extendsThread{30 public voidrun(){31 System.out.println(Thread.currentThread().getName()+"正在执行。。");32 }33 }

View Code

1 pool-1-thread-1正在执行。。2 pool-1-thread-2正在执行。。3 pool-1-thread-1正在执行。。4 pool-1-thread-1正在执行。。5 pool-1-thread-2正在执行。。6 pool-1-thread-1正在执行。。

View Code

5、单任务延迟线程池

在4的代码基础上修改为：

1 ScheduledExecutorService pool=Executors.newSingleThreadScheduledExecutor();

1 pool-1-thread-1正在执行。。2 pool-1-thread-1正在执行。。3 pool-1-thread-1正在执行。。4 pool-1-thread-1正在执行。。5 pool-1-thread-1正在执行。。6 pool-1-thread-1正在执行。。

View Code

6、自定义线程池

1 packageThread;2

3 importjava.util.concurrent.ArrayBlockingQueue;4 importjava.util.concurrent.BlockingQueue;5 importjava.util.concurrent.ExecutorService;6 importjava.util.concurrent.Executors;7 importjava.util.concurrent.ScheduledExecutorService;8 importjava.util.concurrent.ThreadPoolExecutor;9 importjava.util.concurrent.TimeUnit;10

11 public classTest1 {12 public static voidmain(String[] args){13 //ExecutorService pool=Executors.newFixedThreadPool(2);14 //ExecutorService pool=Executors.newSingleThreadExecutor();15 //ExecutorService pool=Executors.newCachedThreadPool();16 //ScheduledExecutorService pool=Executors.newScheduledThreadPool(2);17 //ScheduledExecutorService pool=Executors.newSingleThreadScheduledExecutor();

18 BlockingQueuebqueue=new ArrayBlockingQueue(20);19 ThreadPoolExecutor pool=new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue);20

21 Thread t1=newMyThread_test();22 Thread t2=newMyThread_test();23 Thread t3=newMyThread_test();24 Thread t4=newMyThread_test();25 Thread t5=newMyThread_test();26 Thread t6=newMyThread_test();27 pool.execute(t1);28 pool.execute(t2);29 pool.execute(t3);30 pool.execute(t4);31 pool.execute(t5);32 pool.execute(t6);33 //pool.schedule(t5,10,TimeUnit.MILLISECONDS);34 //pool.schedule(t6,10,TimeUnit.MILLISECONDS);

35 pool.shutdown();36 }37 }38 class MyThread_test extendsThread{39 public voidrun(){40 System.out.println(Thread.currentThread().getName()+"正在执行。。");41 }42 }

View Code

1 pool-1-thread-1正在执行。。2 pool-1-thread-2正在执行。。3 pool-1-thread-1正在执行。。4 pool-1-thread-2正在执行。。5 pool-1-thread-1正在执行。。6 pool-1-thread-2正在执行。。

View Code

创建自定义线程池的构造方法很多，本例中的含义如下：

1 public tThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueueworkQueue)2

3 参数4 corePoolSize：池中所保存的线程数，包括空闲线程。5 maximumPoolSize：池中允许的最大线程数。6 keepAliveTime：当线程大于核心时，此为终止前多余的空前线程等待新任务的最长时间。7 unit-keepAliveTime：参数的时间单位8 workQueue：执行前用于保持任务队列，此队列仅保持有executor方法提交的Runnable任务。9

10 抛出：11 IllegalArgumentException：如果corePoolSize或keepAliveTime小于0或者maximumPoolSize小于等于0，或者说corePoolSize大于maximumPoolSize。12 NullPointerException：如果workQueue为空

虽然自定义线程池麻烦点，但是可以获取当前线程池的尺寸、正在执行任务的线程数、工作队列等。

六、障碍器

当计算一个大的任务时，常常需要分配好多子任务去执行，只有当所有子任务执行完时，才能执行主任务，这时候需要借助障碍器。

1 packageThread;2

3 importjava.util.concurrent.BrokenBarrierException;4 importjava.util.concurrent.CyclicBarrier;5

6 public classCarrierTest {7 public static voidmain(String[] args){8 CyclicBarrier cb=new CyclicBarrier(6,newMainTask());9 new SubTask("A",cb).start();10 new SubTask("B",cb).start();11 new SubTask("C",cb).start();12 new SubTask("D",cb).start();13 new SubTask("E",cb).start();14 new SubTask("F",cb).start();15 }16 }17 class MainTask implementsRunnable{18 public voidrun(){19 System.out.println(">>>>主任务执行了!<<<

32 System.out.println("[子任务"+name+"]开始执行完成了，并通知障碍器已经完成！");33

34 try{35 cb.await();//通知障碍器已经完成

36 }37 catch(InterruptedException e){38 e.printStackTrace();39 }40 catch(BrokenBarrierException e){41 e.printStackTrace();42 }43 }44 }

View Code

1 [子任务C]开始执行了！2 [子任务D]开始执行了！3 [子任务E]开始执行了！4 [子任务B]开始执行了！5 [子任务A]开始执行了！6 [子任务B]开始执行完成了，并通知障碍器已经完成！7 [子任务E]开始执行完成了，并通知障碍器已经完成！8 [子任务D]开始执行完成了，并通知障碍器已经完成！9 [子任务F]开始执行了！10 [子任务C]开始执行完成了，并通知障碍器已经完成！11 [子任务F]开始执行完成了，并通知障碍器已经完成！12 [子任务A]开始执行完成了，并通知障碍器已经完成！13 >>>>主任务执行了!<<<<

View Code