ReentrantLock(重入锁)的使用

//效果和synchronized一样，都可以同步执行，lock方法获得锁，unlock方法释放锁
public class MyService {

    private Lock lock = new ReentrantLock();

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

public class MyService {
    private Lock lock = new ReentrantLock();
    private Condition condition=lock.newCondition();
    public void testMethod() {
        //通过创建Condition对象来使线程wait，必须先执行lock.lock方法获得锁。
//执行await()后，会释放当前锁，当其他线程调用signal()需要重新请求锁

try {
            lock.lock();
            System.out.println("开始wait");
            condition.await();
            for (int i = 0; i < 5; i++) {
                System.out.println("ThreadName=" + Thread.currentThread().getName()
                        + (" " + (i + 1)));
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }
    }
    public void signal()
    {
        try
        {
            lock.lock();
            condition.signal();//condition对象的signal方法可以唤醒wait线程

        }
        finally
        {
            lock.unlock();
        }
    }

}

创建多个condition对象

• 一个condition对象的signal（signalAll）方法和该对象的await方法是一一对应的，也就是一个condition对象的signal（signalAll）方法不能唤醒其他condition对象的await方法
• ReentrantLock类可以唤醒指定条件的线程，而object的唤醒是随机的

Condition类和Object类

• Condition类的awiat方法和Object类的wait方法等效
• Condition类的signal方法和Object类的notify方法等效
• Condition类的signalAll方法和Object类的notifyAll方法等效

Lock的公平锁和非公平锁

Lock lock=new ReentrantLock(true);//公平锁
Lock lock=new ReentrantLock(false);//非公平锁

• 公平锁指的是线程获取锁的顺序是按照加锁顺序来的，而非公平锁指的是抢锁机制，先lock的线程不一定先获得锁。

ReentrantLock自身支持读写锁

lock.readLock().lock();

lock.readLock().unlock();

lock.writeLock().lock();

lock.writeLock().unlock();

• 读锁，此时多个线程可以获得读锁
• 写锁，此时只有一个线程能获得写锁
• 读读共享，写写互斥，读写互斥

参考https://www.cnblogs.com/-new/p/7256297.html