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

一、条件变量

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

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

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

　　CaseTest.java

package Thread;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class CaseTest {
    public static void main(String[] args){
        MyCount1 myCount1=new MyCount1("6516431",10000);
        ExecutorService pool=Executors.newFixedThreadPool(2);
        Thread t1=new SaveThread("张三",myCount1,2000);
        Thread t2=new DrawThread("李四",myCount1,3600);
        Thread t3=new SaveThread("王二",myCount1,2700);
        Thread t4=new SaveThread("麻子",myCount1,600);
        Thread t5=new DrawThread("胖子",myCount1,1300);
        Thread t6=new DrawThread("小刘",myCount1,800);
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
        pool.shutdown();
    }
}
class SaveThread extends Thread{
    private String name;
    private MyCount1 myCount1;
    private int x;
    SaveThread(String name,MyCount1 myCount1,int x){
        this.name=name;
        this.myCount1=myCount1;
        this.x=x;
    }
    public void run(){
        myCount1.saving(x,name);
    }
}
class DrawThread extends Thread{
    private String name;
    private MyCount1 myCount;
    private int x;
    DrawThread(String name,MyCount1 myCount,int x){
        this.name=name;
        this.myCount=myCount;
        this.x=x;
    }
    public void run(){
        myCount.drawing(x,name);
    }
}
class MyCount1{
    private String oid;
    private int cash;
    private Lock lock=new ReentrantLock();
    private Condition _save=lock.newCondition();
    private Condition _draw=lock.newCondition();
    MyCount1(String oid,int cash){
        this.oid=oid;
        this.cash=cash;
    }
    public void saving(int x,String name){
        lock.lock(); //获取锁 
        if(x>0){
            cash+=x;
            System.out.println(name+"存款"+x+",当前余额为："+cash);
        }
        _draw.signalAll(); //唤醒所有等待线程。 
        lock.unlock(); //释放锁 
    }
    public void drawing(int x,String name){
        lock.lock();
        try{
            if(cash-x<0){
                _draw.await();//阻塞取款操作
            }else{    
                cash-=x;
                System.out.println(name+"取款"+x+",当前余额为："+cash);
            }
            _save.signalAll();//唤醒所有存款操作
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
}

　　结果为：

李四取款3600,当前余额为：6400
张三存款2000,当前余额为：8400
王二存款2700,当前余额为：11100
麻子存款600,当前余额为：11700
胖子取款1300,当前余额为：10400
小刘取款800,当前余额为：9600

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

　　CaseTest.java

package Thread;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class CaseTest {
    public static void main(String[] args){
        MyCount1 myCount1=new MyCount1("6516431",10000);
        ExecutorService pool=Executors.newFixedThreadPool(2);
        Thread t1=new SaveThread("张三",myCount1,2000);
        Thread t2=new DrawThread("李四",myCount1,3600);
        Thread t3=new SaveThread("王二",myCount1,2700);
        Thread t4=new SaveThread("麻子",myCount1,600);
        Thread t5=new DrawThread("胖子",myCount1,1300);
        Thread t6=new DrawThread("小刘",myCount1,800);
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
        pool.shutdown();
    }
}
class SaveThread extends Thread{
    private String name;
    private MyCount1 myCount1;
    private int x;
    SaveThread(String name,MyCount1 myCount1,int x){
        this.name=name;
        this.myCount1=myCount1;
        this.x=x;
    }
    public void run(){
        myCount1.saving(x,name);
    }
}
class DrawThread extends Thread{
    private String name;
    private MyCount1 myCount;
    private int x;
    DrawThread(String name,MyCount1 myCount,int x){
        this.name=name;
        this.myCount=myCount;
        this.x=x;
    }
    public void run(){
        myCount.drawing(x,name);
    }
}
class MyCount1{
    private String oid;
    private int cash;
    MyCount1(String oid,int cash){
        this.oid=oid;
        this.cash=cash;
    }
    public synchronized void saving(int x,String name){
        if(x>0){
            cash+=x;
            System.out.println(name+"存款"+x+",当前余额为："+cash);
        }
            notifyAll();
        //_draw.signalAll(); //唤醒所有等待线程。 
        //lock.unlock(); //释放锁 
    }
    public synchronized void drawing(int x,String name){
        if(cash-x<0){
            try{
                wait();
            }
            catch(InterruptedException e){
                e.printStackTrace();
            }
        }else{    
            cash-=x;
            System.out.println(name+"取款"+x+",当前余额为："+cash);
            }
    notifyAll();

    }
}

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

　　CaseTest.java

package Thread;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class CaseTest {
    public static void main(String[] args){
        MyCount1 myCount1=new MyCount1("6516431",10000);
        ExecutorService pool=Executors.newFixedThreadPool(2);
        Thread t1=new SaveThread("张三",myCount1,2000);
        Thread t2=new DrawThread("李四",myCount1,3600);
        Thread t3=new SaveThread("王二",myCount1,2700);
        Thread t4=new SaveThread("麻子",myCount1,600);
        Thread t5=new DrawThread("胖子",myCount1,1300);
        Thread t6=new DrawThread("小刘",myCount1,800);
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
        pool.shutdown();
    }
}
class SaveThread extends Thread{
    private String name;
    private MyCount1 myCount1;
    private int x;
    SaveThread(String name,MyCount1 myCount1,int x){
        this.name=name;
        this.myCount1=myCount1;
        this.x=x;
    }
    public void run(){
        myCount1.saving(x,name);
    }
}
class DrawThread extends Thread{
    private String name;
    private MyCount1 myCount;
    private int x;
    DrawThread(String name,MyCount1 myCount,int x){
        this.name=name;
        this.myCount=myCount;
        this.x=x;
    }
    public void run(){
        myCount.drawing(x,name);
    }
}
class MyCount1{
    private String oid;
    private int cash;
    //private Lock lock=new ReentrantLock();
    //private Condition _save=lock.newCondition();
    //private Condition _draw=lock.newCondition();
    MyCount1(String oid,int cash){
        this.oid=oid;
        this.cash=cash;
    }
    public  void saving(int x,String name){
        synchronized(this){ 
            if(x>0){
                cash+=x;
                System.out.println(name+"存款"+x+",当前余额为："+cash);
            }
            notifyAll();
        }
    }
    public  void drawing(int x,String name){
        synchronized(this){
            if(cash-x<0){
                try{
                    wait();
                }
                catch(InterruptedException e){
                    e.printStackTrace();
                }
                }else{    
                cash-=x;
                System.out.println(name+"取款"+x+",当前余额为："+cash);
            }
            notifyAll();
            }
    }
}

二、Volatile变量

　　具体的内容，详见 JAVA理论与实践：正确使用Volatile变量

三、原子量

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

　　Test.java

package Thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
public class CaseTest {
    public static void main(String[] args){
        ExecutorService pool=Executors.newFixedThreadPool(2);
        Runnable t1=new MyRunnable_2("张三",2000);
        Runnable t2=new MyRunnable_2("李四",3600);
        Runnable t3=new MyRunnable_2("王二",2700);
        Runnable t4=new MyRunnable_2("麻子",600);
        Runnable t5=new MyRunnable_2("胖子",1300);
        Runnable t6=new MyRunnable_2("小刘",800);
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
        pool.shutdown();
    }
}
class MyRunnable_2 implements Runnable{
    private static AtomicLong aLong = new AtomicLong(10000);
    private String name;
    private int x;
    MyRunnable_2(String name,int x){
        this.name=name;
        this.x=x;
    }
    public void run(){
        System.out.println(name+"执行了"+x+",余额为："+aLong.addAndGet(x));
    }
}

　　结果为

/**第一种结果**/
张三执行了2000,余额为：12000
王二执行了2700,余额为：14700
麻子执行了600,余额为：15300
胖子执行了1300,余额为：16600
小刘执行了800,余额为：17400
李四执行了3600,余额为：21000

/**第二种结果**/
张三执行了2000,余额为：15600
李四执行了3600,余额为：13600
王二执行了2700,余额为：18300
麻子执行了600,余额为：18900
胖子执行了1300,余额为：20200
小刘执行了800,余额为：21000

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

　　Test.java

package Thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class CaseTest {
    public static void main(String[] args){
        ExecutorService pool=Executors.newFixedThreadPool(2);
        Lock lock=new ReentrantLock(false);
        Runnable t1=new MyRunnable_2("张三",2000,lock);
        Runnable t2=new MyRunnable_2("李四",3600,lock);
        Runnable t3=new MyRunnable_2("王二",2700,lock);
        Runnable t4=new MyRunnable_2("麻子",600,lock);
        Runnable t5=new MyRunnable_2("胖子",1300,lock);
        Runnable t6=new MyRunnable_2("小刘",800,lock);
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
        pool.shutdown();
    }
}
class MyRunnable_2 implements Runnable{
    private static AtomicLong aLong = new AtomicLong(10000);
    private String name;
    private int x;
    private Lock lock;
    MyRunnable_2(String name,int x,Lock lock){
        this.name=name;
        this.x=x;
        this.lock=lock;
    }
    public void run(){
        lock.lock();
        System.out.println(name+"执行了"+x+",余额为："+aLong.addAndGet(x));
        lock.unlock();
    }
}

　　结果为：

张三执行了2000,余额为：12000
李四执行了3600,余额为：15600
王二执行了2700,余额为：18300
胖子执行了1300,余额为：19600
麻子执行了600,余额为：20200
小刘执行了800,余额为：21000

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

 四、信号量

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

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

　　SignalTest.java

package Thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SignalTest {
    public static void main(String[] args){
        MyPool myPool=new MyPool(20);
        ExecutorService threadPool=Executors.newFixedThreadPool(2);
        MyThread_signal t1=new MyThread_signal("任务A",myPool,3);
        MyThread_signal t2=new MyThread_signal("任务B",myPool,12);
        MyThread_signal t3=new MyThread_signal("任务C",myPool,7);
        threadPool.execute(t1);
        threadPool.execute(t2);
        threadPool.execute(t3);
        threadPool.shutdown();
    }
}
class MyPool{
    private Semaphore sp;//池相关的信号量
    MyPool(int size){this.sp=new Semaphore(size);}
    public Semaphore getSp(){return sp;}
    public void setSp(Semaphore sp){this.sp=sp;}
}
class MyThread_signal extends Thread{
    private String name;
    private MyPool myPool;
    private int x;
    MyThread_signal(String name,MyPool myPool,int x){
        this.name=name;
        this.myPool=myPool;
        this.x=x;
    }
    public void run(){
        try{
            myPool.getSp().acquire();
            System.out.println(name+"成功获取了"+x+"个许可！");
        }
        catch(InterruptedException e){e.printStackTrace();}
        finally{myPool.getSp().release(x);
                System.out.println(name+"释放了"+x+"个许可！");}
    }
}

　　结果为：

任务A成功获取了3个许可！
任务A释放了3个许可！
任务C成功获取了7个许可！
任务C释放了7个许可！
任务B成功获取了12个许可！
任务B释放了12个许可！

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

五、线程池

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

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

1、固定大小的线程池

package Thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test1 {
    public static void main(String[] args){
        ExecutorService pool=Executors.newFixedThreadPool(2);
        Thread t1=new MyThread_test();
        Thread t2=new MyThread_test();
        Thread t3=new MyThread_test();
        Thread t4=new MyThread_test();
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.shutdown();
    }
}
class MyThread_test extends Thread{
    public void run(){
        System.out.println(Thread.currentThread().getName()+"正在执行。。");
    }
}

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

2、单任务线程池

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

ExecutorService pool=Executors.newSingleThreadExecutor();

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

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

3、可变尺寸的线程池

ExecutorService pool=Executors.newCachedThreadPool();

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

4、延迟线程池

package Thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test1 {
    public static void main(String[] args){
        //ExecutorService pool=Executors.newFixedThreadPool(2);
        //ExecutorService pool=Executors.newSingleThreadExecutor();
        //ExecutorService pool=Executors.newCachedThreadPool();
        ScheduledExecutorService pool=Executors.newScheduledThreadPool(2);
        Thread t1=new MyThread_test();
        Thread t2=new MyThread_test();
        Thread t3=new MyThread_test();
        Thread t4=new MyThread_test();
        Thread t5=new MyThread_test();
        Thread t6=new MyThread_test();
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.schedule(t5,10,TimeUnit.MILLISECONDS);
        pool.schedule(t6,10,TimeUnit.MILLISECONDS);
        pool.shutdown();
    }
}
class MyThread_test extends Thread{
    public void run(){
        System.out.println(Thread.currentThread().getName()+"正在执行。。");
    }
}

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

5、单任务延迟线程池

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

ScheduledExecutorService pool=Executors.newSingleThreadScheduledExecutor();

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

6、自定义线程池

package Thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test1 {
    public static void main(String[] args){
        //ExecutorService pool=Executors.newFixedThreadPool(2);
        //ExecutorService pool=Executors.newSingleThreadExecutor();
        //ExecutorService pool=Executors.newCachedThreadPool();
        //ScheduledExecutorService pool=Executors.newScheduledThreadPool(2);
        //ScheduledExecutorService pool=Executors.newSingleThreadScheduledExecutor();
        BlockingQueue<Runnable>bqueue=new ArrayBlockingQueue<Runnable>(20);
        ThreadPoolExecutor pool=new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue);
        
        Thread t1=new MyThread_test();
        Thread t2=new MyThread_test();
        Thread t3=new MyThread_test();
        Thread t4=new MyThread_test();
        Thread t5=new MyThread_test();
        Thread t6=new MyThread_test();
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
    //    pool.schedule(t5,10,TimeUnit.MILLISECONDS);
        //pool.schedule(t6,10,TimeUnit.MILLISECONDS);
        pool.shutdown();
    }
}
class MyThread_test extends Thread{
    public void run(){
        System.out.println(Thread.currentThread().getName()+"正在执行。。");
    }
}

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

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

public tThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable>workQueue)

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

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

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

六、障碍器

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

package Thread;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CarrierTest {
    public static void main(String[] args){
        CyclicBarrier cb=new CyclicBarrier(6,new MainTask());
        new  SubTask("A",cb).start();
        new  SubTask("B",cb).start();
        new  SubTask("C",cb).start();
        new  SubTask("D",cb).start();
        new  SubTask("E",cb).start();
        new  SubTask("F",cb).start();
    }
}
class MainTask implements Runnable{
    public void run(){
        System.out.println(">>>>主任务执行了!<<<<");
    }
}
class SubTask extends Thread{
    private String name;
    private CyclicBarrier cb;
    SubTask(String name,CyclicBarrier cb){
        this.name=name;
        this.cb=cb;
    }
    public void run(){
        System.out.println("[子任务"+name+"]开始执行了！");
        //for(int i=0;i<99999;i++);//模拟耗时的任务
        System.out.println("[子任务"+name+"]开始执行完成了，并通知障碍器已经完成！");
        
        try{
            cb.await();//通知障碍器已经完成
        }
        catch(InterruptedException e){
            e.printStackTrace();
        }
        catch(BrokenBarrierException e){
            e.printStackTrace();
        }
    }
}

[子任务C]开始执行了！
[子任务D]开始执行了！
[子任务E]开始执行了！
[子任务B]开始执行了！
[子任务A]开始执行了！
[子任务B]开始执行完成了，并通知障碍器已经完成！
[子任务E]开始执行完成了，并通知障碍器已经完成！
[子任务D]开始执行完成了，并通知障碍器已经完成！
[子任务F]开始执行了！
[子任务C]开始执行完成了，并通知障碍器已经完成！
[子任务F]开始执行完成了，并通知障碍器已经完成！
[子任务A]开始执行完成了，并通知障碍器已经完成！
>>>>主任务执行了!<<<<