Java Lock的使用

1. ReentrantLock 类

调用ReentrantLock对象的lock()方法获取锁，调用unlock()方法释放锁

class MyService{
    private Lock lock = new ReentrantLock();

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

class MyThread extends Thread {
    private MyService myService;

    public MyThread(MyService myService) {
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.testMethod();
    }
}

public static void main(String[] args) {
    MyService service = new MyService();
    MyThread t1 = new MyThread(service);
    MyThread t2 = new MyThread(service);
    MyThread t3 = new MyThread(service);
    MyThread t4 = new MyThread(service);
    MyThread t5 = new MyThread(service);
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
}

1.1 使用Condition实现等待/通知
关键字synchronized与wait()和notify()/notifyAll()方法相结合可以实现等待/通知模式，类ReentrantLock也可以借助Condition对象实现

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

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

    public void signal() {
        try {
            lock.lock();
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

public static void main(String[] args) {
    try {
        MyCondition myCondition = new MyCondition();

        Thread A = new Thread() {
            @Override
            public void run() {
                myCondition.await();
            }
        };

        Thread B = new Thread() {
            @Override
            public void run() {
                myCondition.signal();
            }
        };

        A.start();
        Thread.sleep(3000);
        B.start();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

//await():1566072576879
//被signal()唤醒:1566072579873

• condition.await() 方法调用之前需要调用lock.lock() 获得同步监视器
• object.wait() 相当于 condition.await()
• object.wait(long) 相当于 condition.await(long, TimeUnit)
• object.notify() 相当于 condition.signal()
• object.notifyAll() 相当于 condition.signalAll()

1.1.1 唤醒指定种类的线程

private Condition conditionA = lock.newCondition();
private Condition conditionB = lock.newCondition();
...
{
	conditionA.await(); //A类等待
}
{
	conditionB.await(); //B类等待
}
{
	conditionA.signalAll(); //唤醒A类等待
}
{
	conditionB.signalAll(); //唤醒B类等待
}

1.2 公平锁和非公平锁
锁Lock分为 公平锁 和 非公平锁，

• 公平锁表示线程获取锁的的顺序是按照线程加锁的顺序来分配的
• 非公平锁随机获得

Lock lock = new ReentrantLock(true/false) 公平/非公平
默认情况下，ReentrantLock类使用的是非公平锁

1.3 getHoldCount()、getQueueLength()、getWaitQueueLength()

• getHoldCount() 查询当前线程保持此锁定的个数，也就是调用lock()方法的次数

  class HoldCount {
      private ReentrantLock lock = new ReentrantLock();
  
      public void method1() {
          try {
              lock.lock();
              method2();
          } finally {
              lock.unlock();
          }
      }
  
      public void method2() {
          try {
              lock.lock();
              System.out.println("lock.getHoldCount(): " + lock.getHoldCount());
          } finally {
              lock.unlock();
          }
      }
  }
  
  public static void main(String[] args) {
      HoldCount holdCount = new HoldCount();
      holdCount.method1();
  }
  
  //lock.getHoldCount(): 2
  

• lock.getQueueLength() 作用是返回正在等待获取此锁定的线程估计数，就是有多少线程同时在等待lock的释放

• lock.getWaitQueueLength(Condition condition) 作用是返回等待与此锁定相关的给定条件Condition的线程估计数。有5个线程执行了同一个condition对象的await()方法，返回5

1.4 hasQueuedThread()、hasQueuedThreads()、hasWaiters()

• lock.hasQueuedThread(Thread thread) 作用是查询指定的线程是否正在等待获取此锁定
• lock.hasQueuedThreads() 作用是查询是否有线程正在等待获取此锁定
• lock.hasWaiters(Condition condition) 作用是查询是否有线程正在等待与此锁定有关的condition条件

1.5 isFair()、isHeldByCurrentThread()、isLocked()

• lock.isFair() 判断是不是公平锁
• lock.isHeldByCurrentThread() 作用是查询当前线程是否保持此锁定
• lock.isLocked() 作用是查询此锁定是否由任意线程保持

1.6 lockInterruptibly()、tryLock()、tryLock(long timeout, TimeUnit unit)

• lock.lockInterruptibly() 如果当前线程未中断，则获取锁定，如果已经被中断则出现异常
• lock.tryLock() 仅在调用时锁定未被另一个线程保持的情况下，才获取该锁定
• lock.tryLock(long, TimeUnit) 如果锁定在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁定

1.7 awaitUninterriptibly()

class AwaitUninterruptibly {
    public Lock lock = new ReentrantLock();
    public Condition condition = lock.newCondition();

    public void testMethod() {
        try {
            lock.lock();
            System.out.println("await...begin");
            condition.await();
            System.out.println("await...end");
        } finally {
            lock.unlock();
        }
    }
}

public static void main(String[] args) {
    try {
        AwaitUninterruptibly awaitUninterruptibly = new AwaitUninterruptibly();
        Thread t = new Thread() {
            @Override
            public void run() {
                awaitUninterruptibly.testMethod();
            }
        };
        t.start();
        Thread.sleep(2000);
        t.interrupt();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

在await状态中interrupt()会报错

//await...begin
java.lang.InterruptedException
	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.reportInterruptAfterWait(AbstractQueuedSynchronizer.java:2014)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2048)
	at com.websocket.service.AwaitUninterruptibly.testMethod(LockTest.java:112)
	at com.websocket.service.LockTest$1.run(LockTest.java:18)

改为condition.awaitUninterriptibly() 后，不会报错，程序不会停止

//await...begin

1.8 awaitUntil()
condition.awaitUntil(Date deadLine) 在等待时间到达后自动唤醒；在等待时间到达前,可以被其他线程提前唤醒

2. ReentrantReadWriterLock 类

类ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.lock()方法后面的任务。这样做虽然保证了实例变量的线程安全性，但效率确实非常低下的。所以JDK中提供了一种读写锁ReentrantReadWriterLock 类，使用它可以加快运行效率，在某些不需要操作实例变量的方法中，完全可以使用读写锁ReentrantReadWriterLock来提升该方法的代码运行速度。

• 一个是读操作相关的锁，也称为共享锁
• 另一个是写操作相关的锁，也叫排他锁

多个读锁之间不互斥，读锁与写锁互斥

• 在没有线程Thread进行写入操作时，进行读取操作的多个Thread都可以获取读锁
• 进行写入操作的Thread只有在获取写锁后才能进行写入操作

即多个Thread可以同时进行读取操作，但是同一时刻只允许一个Thread进行写入操作

ReentrantReadWriterLock lock = new ReentrantReadWriterLock();
...
lock.readLock().lock(); //获取读锁
... //允许多个线程同时进入lock()后面的代码
lock.readLock.unLock();

lock.writeLock().lock(); //获取写锁
... //同一时间只允许一个线程执行lock()后面的代码
lock.writeLock().unLock();

两个线程，一个lock，一个获取读锁，一个获取写锁，“读写”、"写读"都是互斥的。只要出现写操作，就是互斥的