Java多线程之Lock的使用（一）

Java多线程中，可使用synchronized关键字实现线程之间同步互斥，JDK1.5中新增长了ReentrantLock类也能够达到一样的效果，而且更增强大。

如何使用

class MyService {
   private var lock: Lock = ReentrantLock()
   fun testMethod() {
       lock.lock() //获取锁
       for (i in 1..5) {
           println("ThreadName is ${Thread.currentThread().name} $i")
       }
       lock.unlock()   //释放锁
   }
}复制代码

如代码所示，调用ReentrantLock对象的lock()方法获取锁，调用unlock()方法释放锁。

调用lock.lock()代码的线程就持有了“对象监视器”，其余线程就只有等待锁被释放时再次争抢。效果和synchronized关键字同样，线程之间执行的顺序时随机的。

使用Condition实现等待/通知

关键字synchronized与wait()和notify()/notifyAll()方法结合能够实现等待/通知模式，类ReentrantLock也能够实现一样的功能，但须要借助于Condition对象。

Condition类是JDK1.5中出现的技术，使用它有更好的灵活性，好比能够实现多路通知功能，也就是在一个Lock对象里面建立多个Condition（即对象监视器）实例，线程对象能够注册在指定的Condition中，从而能够有选择的进行线程通知。

在使用notify()方法进行通知的时候，被通知的线程是由JVM随机选择的。使用ReentrantLock结合Condition是能够实现“选择性通知”的。

synchronized至关于整个Lock对象中只有一个单一的Condition对象，全部线程都注册在它一个对象上。

实现代码以下：

class MyService {

    private var lock: Lock = ReentrantLock()

    private var condition: Condition = lock.newCondition()

    fun await() {
        try {
            lock.lock()
            println("await时间为： ${System.currentTimeMillis()}")
            condition.await()
        } catch(e: InterruptedException) {
            e.printStackTrace()
        } finally {
            lock.unlock()
        }
    }

    fun signal() {
        try {
            lock.lock()
            println("signal时间为：${System.currentTimeMillis()}")
            condition.signal()
        } finally {
            lock.unlock()
        }
    }
}复制代码

Object类中的wait()方法至关于Condition类中的await()方法，Object类中的notify至关于Condition中的signal()。

使用多个Condition实现通知部分线程

实现代码以下：

class MyService {

    private var lock: Lock = ReentrantLock()

    private var conditionA: Condition = lock.newCondition()
    private var conditionB: Condition = lock.newCondition()

    fun awaitA() {
        try {
            lock.lock()
            println("begin awaitA时间为：${System.currentTimeMillis()} ThreadName = ${Thread.currentThread().name}")
            conditionA.await()
            println("end awaitA时间为：${System.currentTimeMillis()} ThreadName = ${Thread.currentThread().name}")
        } catch(e: InterruptedException) {
            e.printStackTrace()
        } finally {
            lock.unlock()
        }
    }

    fun awaitB() {
        try {
            lock.lock()
            println("begin awaitB时间为：${System.currentTimeMillis()} ThreadName = ${Thread.currentThread().name}")
            conditionB.await()
            println("end awaitB时间为：${System.currentTimeMillis()} ThreadName = ${Thread.currentThread().name}")
        } catch(e: InterruptedException) {
            e.printStackTrace()
        } finally {
            lock.unlock()
        }
    }

    fun signalAll_A() {
        try {
            lock.lock()
            println("signalAll_A时间为：${System.currentTimeMillis()} ThreadName = ${Thread.currentThread().name}")
            conditionA.signalAll()
        } finally {
            lock.unlock()
        }
    }

    fun signalAll_B() {
        try {
            lock.lock()
            println("signalAll_B时间为：${System.currentTimeMillis()} ThreadName = ${Thread.currentThread().name}")
            conditionB.signalAll()
        } finally {
            lock.unlock()
        }
    }
}复制代码

公平锁与非公平锁

锁Lock分为“公平锁”和“非公平锁”，公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO顺序。而非公平锁就是一种获取锁的抢占机制，是随机得到锁的。

• 建立公平锁：

  var lock: Lock = ReentrantLock(true)复制代码

  or

  var lock: Lock = ReentrantLock()复制代码

• 建立非公平锁：

  var lock: Lock = ReentrantLock(false)复制代码

ReentrantLock一些经常使用的方法

• getHolderCount():int - 查询当前线程保持此锁定的个数

• getQueueLength():int - 获取正在等待获取此锁定的线程估计数

  好比有5个线程，一个线程首先执行await()方法，那么调用getQueueLength()方法的返回值是4，说明4个线程同时等待lock的释放。

• getWaitQueueLength(Condition):int - 返回等待与此锁定相关的给定条件Condition的线程估计数

  好比有5个线程，每一个线程都执行了同一个Condition对象的await()方法，则调用getWaitQueueLength()方法时返回5

• hasQueuedThread(Thread):boolean - 查询指定的线程是否正在等待获取此锁定

• hasQueuedThreads():boolean - 查询是否有线程正在等待获取此锁定

• hasWaiters(Condition):boolean - 查询是否有线程正在等待与此锁定有关的Condition条件

• isFair():boolean - 判断是否是公平锁

• isHeldByCurrentThread():boolean - 查询当前线程是否保持锁定

• isLocked():boolean - 查询此锁定是否由任意线程保持

• lockInterruptibly():void - 若是当前线程未被中断，则获取锁定，若是已经被中断则出现异常

• tryLock():boolean - 仅在调用时锁定未被另外一个线程保持的状况下，才获取该锁定

• tryLock(long,TimeUnit):boolean - 若是锁定在给定等待时间内没有被另外一个线程保持，且当前线程未被中断，则获取该锁定

• awaitUnintterruptibly():void - 进入没法被打断的等待状态