Java多线程中条件对象Condition的使用方法和示例代码

Java中的多线程技术可以有效地提高程序的运行效率，而条件对象Condition就是用来实现线程间协作的重要工具。Condition是java.util.concurrent.locks.Condition接口的实现，它是一个控制多线程之间交互的工具，可以替代Object的wait()、notify()、notifyAll()实现线程间的协调。

Condition的使用方法

Condition的使用方法有两步：

• 从ReentrantLock获取一个Condition实例，通过调用ReentrantLock的newCondition()方法获取；
• 调用Condition实例的await()方法使当前线程等待，调用signal()或signalAll()方法唤醒等待的线程。

Condition的示例代码

public class ConditionTest {
    public static void main(String[] args) {
        // 创建并发访问的账户
        MyCount myCount = new MyCount("95599200901215522", 10000);
        // 创建一个锁对象
        Lock lock = new ReentrantLock();
        // 创建一个Condition
        Condition condition = lock.newCondition();
        // 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        Thread t1 = new SaveThread("张三", myCount, 2000, lock, condition);
        Thread t2 = new DrawThread("李四", myCount, 3600, lock, condition);
        // 执行各个线程
        pool.execute(t1);
        pool.execute(t2);
        // 关闭线程池
        pool.shutdown();
    }
}

class MyCount {
    private String oid;
    private int cash;

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

    public String getOid() {
        return oid;
    }

    public void setOid(String oid) {
        this.oid = oid;
    }

    public int getCash() {
        return cash;
    }

    public void setCash(int cash) {
        this.cash = cash;
    }
}

// 存款线程类
class SaveThread extends Thread {
    private String name;
    private MyCount myCount;
    private int x;
    private Lock lock;
    private Condition condition;

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

    public void run() {
        lock.lock(); // 获取锁
        try {
            // 获取当前账户余额
            int cash = myCount.getCash();
            // 判断当前账户余额是否大于取款数目
            if (cash >= x) {
                System.out.println(name + "取款成功，取出：" + x + "，余额为：" + (cash - x));
                myCount.setCash(cash - x);
                condition.signalAll();
            } else {
                System.out.println(name + "取款失败，余额不足！");
                condition.await();
            }
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

// 取款线程类
class DrawThread extends Thread {
    private String name;
    private MyCount myCount;
    private int x;
    private Lock lock;
    private Condition condition;

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

    public void run() {
        lock.lock(); // 获取锁
        try {
            // 获取当前账户余额
            int cash = myCount.getCash();
            // 判断当前账户余额是否大于取款数目
            if (cash >= x) {
                System.out.println(name + "取款成功，取出：" + x + "，余额为：" + (cash - x));
                myCount.setCash(cash - x);
                condition.signalAll();
            } else {
                System.out.println(name + "取款失败，余额不足！");
                condition.await();
            }
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

上面的示例中，创建了两个线程t1和t2，t1线程用来存款，t2线程用来取款。当账户余额不足时，t2线程会被阻塞，直到t1线程存入指定金额之后，t2线程才会被唤醒。这里使用Condition的await()和signal()方法实现了线程间的协作。

通过使用Condition，可以更加精确地控制多个线程之间的协调，确保线程之间的正确交互。