ReentrantLock可重入锁

在Java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增加了ReentrantLock类也能达到同样的效果，并且扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知等功能，而且在使用上也比synchronized更加的灵活

实现synchronized功能

class Service {

    private Lock lock = new ReentrantLock();

    public void a() {
        lock.lock();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "-" + (i + 1));
        }
        lock.unlock();
    }
}

class SThread implements Runnable {

    private Service service;

    public SThread(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.a();
    }
}

public class Run {

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        for (int i = 0; i < 5; i++) {
            Thread sThread = new Thread(new SThread(service));
            sThread.start();
        }
    }
}

实现wait和notify/notifyAll功能

Object类中的wait()方法相当于Condition类中的await()方法
Object类中的wait(long timeout)方法相当于Condition类中的await(long timeout, TimeUnit unit)方法
Object类中的notify()方法相当于Condition类中的signal()方法
Object类中的notifyAll()方法相当于Condition类中的singalAll()方法

在使用notify()/notifyAll()方法进行通知时，被通知的线程是由JVM随机选择的
Condition可以实现多路通知功能，也就是在一个Lock对象里面可以创建多个Condition（对象监视器）实例，线程对象可以注册在指定的Condition中，从而可以有选择地进行线程通知

class Service {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void await() {
        try {
            lock.lock();
            System.out.println("await: " + System.currentTimeMillis());
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signal() {
        try {
            lock.lock();
            System.out.println("signal: " + System.currentTimeMillis());
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

class SThread implements Runnable {

    private Service service;

    public SThread(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.await();
    }
}

public class Run {

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        Thread sThread = new Thread(new SThread(service));
        sThread.start();
        Thread.sleep(3000);
        service.signal();
    }
}

对个Condition实现通知部分线程

class Service {

    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();

    public void awaitA() {
        try {
            lock.lock();
            System.out.println("awaitA: " + System.currentTimeMillis());
            conditionA.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void awaitB() {
        try {
            lock.lock();
            System.out.println("awaitB: " + System.currentTimeMillis());
            conditionB.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signalA() {
        try {
            lock.lock();
            System.out.println("signalA: " + System.currentTimeMillis());
            conditionA.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void signalB() {
        try {
            lock.lock();
            System.out.println("signalB: " + System.currentTimeMillis());
            conditionB.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

class SThreadA implements Runnable {

    private Service service;

    public SThreadA(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitA();
    }
}

class SThreadB implements Runnable {

    private Service service;

    public SThreadB(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitB();
    }
}

public class Run {

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        Thread sThreadA = new Thread(new SThreadA(service));
        Thread sThreadB = new Thread(new SThreadB(service));
        sThreadA.start();
        sThreadB.start();
        Thread.sleep(3000);
        service.signalA();
    }
}