Lock和Condition

Lock锁

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具

java.util.concurrent.locks.ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中比较常用，可以显式加锁、释放锁

ReentrantLock( )：构造一个重入锁，可以用来保护临界区

ReentranLock(boolean fair)：构造一个采用公平策略的锁，比常规锁慢很多，严重影响性能

class MyClass implements Runnable {
    private int num = 1;
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (num <= 100) {
            try {
                lock.lock();  // 调用锁定方法lock()
                if (num <= 100) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " 数字：" + num);
                    num++;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();  // 调用解锁方法unlock()
            }
        }
    }
}

Condition

条件对象 java.util.concurrent.locks.Condition

Condition因素出Object监视器方法（ wait ， notify 和 notifyAll ）成不同的对象，以得到具有多个等待集的每个对象，
通过将它们与使用任意的组合的效果Lock个实现。
Lock替换synchronized方法和语句的使用， Condition取代了对象监视器方法的使用

条件（也称为条件队列或条件变量 ）为一个线程暂停执行（“等待”）提供了一种方法，
直到另一个线程通知某些状态现在可能为真。 因为访问此共享状态信息发生在不同的线程中，
所以它必须被保护，因此某种形式的锁与该条件相关联。
等待条件的关键属性是它原子地释放相关的锁并挂起当前线程，就像Object.wait

线程进入临界区后却发现只有满足了某个条件之后它才能执行，可以使用一个条件对象来管理那些已经获得了一个锁却不能做有用工作的线程

一个锁对象可以有一个或多个相关联的条件对象，用 newCondition 方法获得一个条件对象

• void await( )：将该线程放在这个条件的等待集中；与此相关的锁Condition以原子方式释放，并且当前线程的线程调度目的退出
• void signalAll( )：解除该条件等待集中所有线程的阻塞状态
• void signal( )：从该条件的等待集中随机选择一个线程，解除其阻塞状态

举例1（put 和 take）

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionTest {
    final static Lock lock = new ReentrantLock();  //锁
    final static Condition notFull = lock.newCondition();  //条件对象1：存满
    final static Condition notEmpty = lock.newCondition();  //条件对象2：空库存
    final static Object[] items = new Object[20];  //存放数组对象，长度20
    static int count, putIndex, takeIndex;  //库存数量，存放位置索引，取出位置索引

    public void put(Object o) throws InterruptedException{
        lock.lock();  //上锁
        try {
            while (count == items.length)  //判断是否存满
                notFull.await();  //已存满，将想要存放进库的线程放入等待集，有item被取出了才释放
            items[putIndex] = o;  //未存满，存入数组
            if (++putIndex == items.length)  //正好存满，存放位置索引置0
                putIndex = 0;
            count++;
            notEmpty.signal();  //有线程想取出item，但是没有库存，直到有item成功存入后，才释放一个取item的线程。一个一个的取，如果有多个取的线程，不要直接signalAll
        } finally {
            lock.unlock();  //解锁，允许下一个线程来调用put方法
        }

    }

    public Object take() throws InterruptedException {
        lock.lock();  //上锁
        try {
            while (count == 0)  //判断库存是否为空
                notEmpty.await();  //库存为空，将想要取item的线程放入等待集，等到有库存了才被释放
            Object o = items[takeIndex];  //有库存，取出一个item
            if (++takeIndex == items.length)  //取到了最后一个位置，取出位置索引置0
                takeIndex = 0;
            count--;
            notFull.signal();  //有线程想存入item，但是库存已满，直到有item被取出后，有空余位置了，才释放一个存item的线程
            return o;
        } finally {
            lock.unlock();  //解锁，允许下一个线程来调用take方法
        }
    }

    public static void main(String[] args) {
        ConditionTest ct = new ConditionTest();
        Runnable r1 = () -> {  // task1，执行put方法，存入一个Object对象
            try {
                while (true) {
                    ct.put(new Object());
                    System.out.println(Thread.currentThread().getName() + " input an item, remain: " + count);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        Runnable r2 = () -> {  // task2，执行take方法，取出一个Object对象
            try {
                while (true) {
                    ct.take();
                    System.out.println(Thread.currentThread().getName() + " take out an item, remain: " + count);
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        Thread t1 = new Thread(r1);  //造线程，执行task1
        Thread t2 = new Thread(r2);  //造线程，执行task2
        t1.start();
        t2.start();
    }
}

举例2（转账）

import java.util.Arrays;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
    private static int COUNTS = 20;
    private static double INITIAL_BALANCE = 1000;
    private static double MAX_AMOUNT = 1000;
    private static int DELAY = 1000;

    public static void main(String[] args) {
        Bank bank = new Bank(COUNTS, INITIAL_BALANCE);
        for (int i = 0; i < bank.size(); i++) {
            int fromAccount = i;
            Runnable r = () -> {
                try {
                    while (true) {
                        int toAccount = (int) (Math.random() * bank.size());
                        double amount = Math.random() * MAX_AMOUNT;
                        bank.transfer(fromAccount, toAccount, amount);
                        Thread.sleep(DELAY);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            Thread thread = new Thread(r);
            thread.start();
        }

    }
}

class Bank {
    private final double[] accounts;
    private Lock bankLock;
    private Condition sufficientFunds;

    public Bank(int n, double initialBalance) {  // 账户个数，每个账户初始存款
        accounts = new double[n];
        Arrays.fill(accounts, initialBalance);
        bankLock = new ReentrantLock();
        sufficientFunds = bankLock.newCondition();
    }

    //转账功能，以数组下标表示账户号码
    public void transfer(int from, int to, double amount) throws InterruptedException {
        bankLock.lock();  // 上锁
        try {
            while (accounts[from] < amount)
                sufficientFunds.await();  // 不满足条件的线程将其加入等待集
            System.out.print(Thread.currentThread().getName());
            accounts[from] -= amount;
            System.out.printf(" %10.2f from %d to %d", amount, from, to);
            accounts[to] += amount;
            System.out.printf(", TotalBalance:%10.2f\n", getTotalBalance());
            sufficientFunds.signalAll();  // 激活等待这个条件的所有线程
        } finally {
            bankLock.unlock();  // 释放锁
        }
    }

    public double getTotalBalance() {
        bankLock.lock();
        try {
            double sum = 0;
            for (double balance : accounts)
                sum += balance;
            return sum;
        } finally {
            bankLock.unlock();
        }
    }

    public int size() {
        return accounts.length;
    }
}