Lock接口

java.util.concurrent.locks包下
1.5jdk之后有的

Lock接口

（1）Lock和ReadWriteLock是两大锁的根接口，Lock代表实现类是ReentrantLock（可重入锁），ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock。

（2）Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。

Lock接口有6个方法

// 获取锁  
void lock()   

// 如果当前线程未被中断，则获取锁，可以响应中断  
void lockInterruptibly()   

// 返回绑定到此 Lock 实例的新 Condition 实例  
Condition newCondition()   

// 仅在调用时锁为空闲状态才获取该锁，可以响应中断  
boolean tryLock()   

// 如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁  
boolean tryLock(long time, TimeUnit unit)   

// 释放锁  
void unlock()

释放锁的操作务必放在finally代码块中

ReentrantLock

ReentrantLock，即 可重入锁。ReentrantLock是唯一实现了Lock接口的类。

构造方法（不带参数 和带参数 true： 公平锁； false: 非公平锁）：

public class LockTest {

    Lock lock = new ReentrantLock();
    private  int i ;

    public void sayHell(String name){
        try{
        lock.lock();
            System.out.println("获取锁");
            i++;
            System.out.println("我的名字是:"+name+",我的编号是:"+i);
        }finally {
            lock.unlock();
            System.out.println("释放锁");
        }
    }

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();
        new Thread(()->{lockTest.sayHell("roy");}).start();
        new Thread(()->{lockTest.sayHell("amy");}).start();
        new Thread(()->{lockTest.sayHell("jhon");}).start();

    }
}

ReadWriteLock

ReentrantReadWriteLock实现类

public class LockTest2 {

     int i = 10;
     ReadWriteLock rwl = new ReentrantReadWriteLock();

     public void get(){
         Lock readLock = null;
         try{
         readLock = rwl.readLock();//读写是共享锁，可以同时访问
         System.out.println(Thread.currentThread().getId()+"获取读锁");
         readLock.lock();
         System.out.println("i的值为:"+i);
         }finally {
             if(readLock!=null)
             readLock.unlock();
             System.out.println(Thread.currentThread().getId()+"释放读锁");
         }
     }

     public void set(){
         Lock wrlock = null;
         try{
             wrlock = rwl.writeLock(); //写锁是互斥锁
             System.out.println(Thread.currentThread().getId()+"获取到写锁");
             wrlock.lock();
             i ++;
             System.out.println("修改了i的值:"+i);
         }finally {
             if (wrlock != null)
                 wrlock.unlock();
             System.out.println(Thread.currentThread().getId()+"释放写锁");
         }
     }

    public static void main(String[] args) {
        LockTest2 lockTest2 = new LockTest2();
        for (int i =0;i<10;i++){
            new Thread(lockTest2::get).start();
        }
        for (int i =0;i<10;i++){
            new Thread(lockTest2::set).start();
        }
        for (int i =0;i<10;i++){
            new Thread(lockTest2::get).start();
        }
        while (Thread.activeCount()==1){
           System.out.println("退出");
            return;
        }
    }
}