java并发编程——通过ReentrantLock,Condition实…

/**
 * 普通银行账户，不可透支
 */
public class MyCount {
    private String oid; // 账号
    private int cash;   // 账户余额
    //账户锁，这里采用公平锁，挂起的取款线程优先获得锁，而不是让其它存取款线程获得锁
    private Lock lock = new ReentrantLock(true);
    private Condition _save = lock.newCondition(); // 存款条件
    private Condition _draw = lock.newCondition(); // 取款条件

    MyCount(String oid, int cash) {
        this.oid = oid;
        this.cash = cash;
    }

    /**
     * 存款
     * @param x 操作金额
     * @param name 操作人
     */
    public void saving(int x, String name) {
        lock.lock(); // 获取锁
        if (x > 0) {
            cash += x; // 存款
            System.out.println(name + "存款" + x + "，当前余额为" + cash);
        }
        _draw.signalAll(); // 唤醒所有等待线程。
        lock.unlock(); // 释放锁
    }

    /**
     * 取款
     * @param x  操作金额
     * @param name 操作人
     */
    public void drawing(int x, String name) {
        lock.lock(); // 获取锁
        try {
            if (cash - x < 0) {
                System.out.println(name + "阻塞中");
                _draw.await(2000,TimeUnit.MILLISECONDS); // 阻塞取款操作, await之后就隐示自动释放了lock，直到被唤醒自动获取
            }
            if(cash-x>=0){
                cash -= x; // 取款
                System.out.println(name + "取款" + x + "，当前余额为" + cash);
            }else{
                System.out.println(name+" 余额不足,当前余额为 "+cash+"   取款金额为 "+x);
            }
            // 唤醒所有存款操作，这里并没有什么实际作用，因为存款代码中没有阻塞的操作
            _save.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

 /**
     * 存款线程类
     */
    static class SaveThread extends Thread {
        private String name; // 操作人
        private MyCount myCount; // 账户
        private int x; // 存款金额

        SaveThread(String name, MyCount myCount, int x) {
            this.name = name;
            this.myCount = myCount;
            this.x = x;
        }

        public void run() {
            myCount.saving(x, name);
        }
    }

    /**
     * 取款线程类
     */
    static class DrawThread extends Thread {
        private String name; // 操作人
        private MyCount myCount; // 账户
        private int x; // 存款金额

        DrawThread(String name, MyCount myCount, int x) {
            this.name = name;
            this.myCount = myCount;
            this.x = x;
        }

        public void run() {
            myCount.drawing(x, name);
        }
    }

    public static void main(String[] args) {
        // 创建并发访问的账户
        MyCount myCount = new MyCount("95599200901215522", 1000);
        // 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);
        Thread t1 = new SaveThread("S1", myCount, 100);
        Thread t2 = new SaveThread("S2", myCount, 1000);
        Thread t3 = new DrawThread("D1", myCount, 12600);
        Thread t4 = new SaveThread("S3", myCount, 600);
        Thread t5 = new DrawThread("D2", myCount, 2300);
        Thread t6 = new DrawThread("D3", myCount, 1800);
        Thread t7 = new SaveThread("S4", myCount, 200);
        // 执行各个线程
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
        pool.execute(t7);

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 关闭线程池
        pool.shutdown();
    }
}

S1存款100，当前余额为1100
S3存款600，当前余额为1700
D2阻塞中
S2存款1000，当前余额为2700
D2取款2300，当前余额为400
D3阻塞中
S4存款200，当前余额为600
D3 余额不足,当前余额为 600 取款金额为 1800
D1阻塞中
D1 余额不足,当前余额为 600 取款金额为 12600

1存款100，当前余额为1100
S3存款600，当前余额为1700
D2阻塞中
S2存款1000，当前余额为2700
D3取款1800，当前余额为900
D2 余额不足,当前余额为 900   取款金额为 2300
S4存款200，当前余额为1100
D1阻塞中
D1 余额不足,当前余额为 1100   取款金额为 12600

 /** The queued items */
    final Object[] items;

    /** items index for next take, poll, peek or remove */
    int takeIndex;

    /** items index for next put, offer, or add */
    int putIndex;

    /** Number of elements in the queue */
    int count;

    /*
     * Concurrency control uses the classic two-condition algorithm
     * found in any textbook.
     */

    /** Main lock guarding all access */

    // 主要解决多线程访问的线程安全性问题
    final ReentrantLock lock;

    /** Condition for waiting takes */

    // 添加元素时，通过notEmpty 唤醒消费线程（在等待该条件）
    private final Condition notEmpty;

    /** Condition for waiting puts */

    // 删除元素时，通过 notFull 唤醒生成线程（在等待该条件）
    private final Condition notFull;