Java并发19:Lock系列-Lock接口基本方法学习实例

[超级链接：Java并发学习系列-绪论]

Lock接口在之前的章节中多次提及：

Java并发02:Java并发Concurrent技术发展简史(各版本JDK中的并发技术)

Java并发12:并发三特性-原子性、可见性和有序性概述及问题示例

Java并发13:并发三特性-原子性定义、原子性问题与原子性保证技术

Java并发14:并发三特性-可见性定义、可见性问题与可见性保证技术

Java并发15:并发三特性-有序性定义、有序性问题与有序性保证技术

Java并发18:Lock接口与synchronized关键字的比较

本章主要通过解读Lock接口的源码，来学习Lock接口定义的方法的使用。

1.源码注释

Lock接口，定义了如下方法：

/**
* Lock接口
* @since 1.5
* @author Doug Lea
*/
public interface Lock {

/**
* Acquires the lock.
*
* <p>If the lock is not available then the current thread becomes
* disabled for thread scheduling purposes and lies dormant until the
* lock has been acquired.
*/
void lock();

/**
* Acquires the lock unless the current thread is
* {@linkplain Thread#interrupt interrupted}.
*
* <p>Acquires the lock if it is available and returns immediately.
*
* <p>If the lock is not available then the current thread becomes
* disabled for thread scheduling purposes and lies dormant until
* one of two things happens:
*
* <ul>
* <li>The lock is acquired by the current thread; or
* <li>Some other thread {@linkplain Thread#interrupt interrupts} the
* current thread, and interruption of lock acquisition is supported.
* </ul>
*
* <p>If the current thread:
* <ul>
* <li>has its interrupted status set on entry to this method; or
* <li>is {@linkplain Thread#interrupt interrupted} while acquiring the
* lock, and interruption of lock acquisition is supported,
* </ul>
* then {@link InterruptedException} is thrown and the current thread's
* interrupted status is cleared.
*/
void lockInterruptibly() throws InterruptedException;

/**
* Acquires the lock only if it is free at the time of invocation.
*
* <p>Acquires the lock if it is available and returns immediately
* with the value {@code true}.
* If the lock is not available then this method will return
* immediately with the value {@code false}.
*
* <p>A typical usage idiom for this method would be:
*  <pre> {@code
* Lock lock = ...;
* if (lock.tryLock()) {
*   try {
*     // manipulate protected state
*   } finally {
*     lock.unlock();
*   }
* } else {
*   // perform alternative actions
* }}</pre>
*
* This usage ensures that the lock is unlocked if it was acquired, and
* doesn't try to unlock if the lock was not acquired.
*
* @return {@code true} if the lock was acquired and
*         {@code false} otherwise
*/
boolean tryLock();

/**
* Acquires the lock if it is free within the given waiting time and the
* current thread has not been {@linkplain Thread#interrupt interrupted}.
*
* <p>If the lock is available this method returns immediately
* with the value {@code true}.
* If the lock is not available then
* the current thread becomes disabled for thread scheduling
* purposes and lies dormant until one of three things happens:
* <ul>
* <li>The lock is acquired by the current thread; or
* <li>Some other thread {@linkplain Thread#interrupt interrupts} the
* current thread, and interruption of lock acquisition is supported; or
* <li>The specified waiting time elapses
* </ul>
*
* <p>If the lock is acquired then the value {@code true} is returned.
*
* <p>If the current thread:
* <ul>
* <li>has its interrupted status set on entry to this method; or
* <li>is {@linkplain Thread#interrupt interrupted} while acquiring
* the lock, and interruption of lock acquisition is supported,
* </ul>
* then {@link InterruptedException} is thrown and the current thread's
* interrupted status is cleared.
*
* <p>If the specified waiting time elapses then the value {@code false}
* is returned.
* If the time is
* less than or equal to zero, the method will not wait at all.
*/
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

/**
* Releases the lock.
*
* <p><b>Implementation Considerations</b>
*
* <p>A {@code Lock} implementation will usually impose
* restrictions on which thread can release a lock (typically only the
* holder of the lock can release it) and may throw
* an (unchecked) exception if the restriction is violated.
* Any restrictions and the exception
* type must be documented by that {@code Lock} implementation.
*/
void unlock();

/**
* Returns a new {@link Condition} instance that is bound to this
* {@code Lock} instance.
*
* <p>Before waiting on the condition the lock must be held by the
* current thread.
* A call to {@link Condition#await()} will atomically release the lock
* before waiting and re-acquire the lock before the wait returns.
*/
Condition newCondition();
}

2.源码解读

通过解读上面的源码，将Lock接口提供的方法总结如下：

1. void lock();

尝试去获得锁。

如果锁不可用，则为了线程调度的目的，当前线程会变得不可用，直到获得锁为止。

2.void lockInterruptibly() throws InterruptedException;

尝试去获得锁，除非当前线程被中断。

如果锁不可用，则为了线程调度的目的，当前线程会变得不可用，直到出现以下两种情况之一：

当前线程获取锁。

其他的线程中断了这个线程。

如果当前线程在获取锁操作中，被其他线程中断，则会抛出InterruptedException异常，并且将中断标识清除。

3.boolean tryLock();

只有在调用时锁是空闲的，才获取锁。

如果锁空闲，则获取锁，并立即返回true值。

如果锁不可用，则立即返回false值。

tryLock()方法的典型使用方式如下：

Lock lock = ...;
if (lock.tryLock()) {//如果锁空闲，就获取锁
try {
// manipulate protected state
} finally {
lock.unlock();//获取了锁就要记得释放
}
} else {//没获取锁，那就干点别的
// perform alternative actions
}

上述方式能够保证：如果获取了锁能够释放锁；如果没获取锁，也不会去尝试释放锁。

4.boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

如果在限定时间内，锁可用并且当前线程不被中断，则获取锁。

如果锁空闲，则获取锁，并立即返回true值。

如果锁不可用，则为了线程调度的目的，当前线程会变得不可用，直到出现以下三种情况之一：

当前线程获取锁。

其他的线程中断了这个线程。

限定时间超时。

针对上面三种情况，当前方法会分别作出以下操作：

如果获得锁，则即返回true值。

如果当前线程在获取锁操作中，被其他线程中断，则会抛出InterruptedException异常，并且将中断标识清除。

如果限定时间超时，则即返回false值。

5.void unlock();

解锁，或者叫释放锁。

通常这样释放锁：

//获取锁
try {
// 共享资源处理
} finally {
l.unlock();//释放锁
}

6.Condition newCondition();

获取一个绑定到当前Lock对象的Condition对象。

获取Condition对象的前提是当前线程持有Lock对象。

关于Condition的相关内容会在下个章节中进行学习。

3.实例代码

实例场景：

定义5个线程。

[Thread-0]刚开始就获取了锁，并且会持有锁5000毫秒才会解锁。

[Thread-1]通过lock.lock()去获取锁，获取锁之后会持有10毫秒然后释放。

[Thread-2]通过lock.tryLock()去获取锁，获取锁之后会持有10毫秒然后释放。

[Thread-3]通过lock.tryLock(long,TimeUnit)尝试在2秒内去获取锁，获取锁之后会持有10毫秒然后释放。

[Thread-4]通过通过lock.lockInterruptibly()去获取锁，获取锁之后会持有10毫秒然后释放。

在所有线程启动3000毫秒后，中断[Thread-4]。

结果预测：

通过上面对方法的解读，结合实例场景，可以推断程序执行结果如下：

刚开始，[Thread-0]就获得了锁。

[Thread-1]通过lock.lock()去获取锁，因为这种操作是阻塞的、不可中断、不可超时的，所以它会一直等待，直到[Thread-0]释放锁。

[Thread-2]通过lock.tryLock()去获取锁，因为当时锁被占用，所以没有获取锁，[Thread-2]不再尝试去获取锁。

[Thread-3]通过lock.tryLock(long,TimeUnit)尝试在2秒内去获取锁，因为超时时间2秒短于5000毫秒，所以[Thread-3]没有获取锁，并在超时之后不再尝试去获取锁。

[Thread-4]通过通过lock.lockInterruptibly()去获取锁，并且在3000毫秒时被main线程中断，所以[Thread-4]没有获取锁，并在被中断之后不再尝试去获取锁。

实例代码：

根据实例场景编写代码如下：

/**
* <p>Lock接口-方法学习-可中断锁、可定时锁</p>
*
* @author hanchao 2018/3/18 13:58
**/
public class LockDemo {

//定义一个非公平的锁
private static Lock lock = new ReentrantLock(false);

/**
* <p>Lock接口方法学习</p>
*
* @author hanchao 2018/3/18 13:54
**/
public static void main(String[] args) throws InterruptedException {
//线程0一直持有锁5000毫秒
new Thread(() -> {
System.out.println("线程[" + Thread.currentThread().getName() + "]尝试获取锁");
lock.lock();
System.out.println("线程[" + Thread.currentThread().getName() + "]获取了锁...");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {//在finally代码块中是否锁
lock.unlock();
System.out.println("线程[" + Thread.currentThread().getName() + "]释放了锁..");
}
}).start();
Thread.sleep(10);
//线程1通过lock.lock()持续去尝试获取锁
new Thread(() -> {
System.out.println("线程[" + Thread.currentThread().getName() + "]通过lock.lock()持续去尝试获取锁");
lock.lock();
System.out.println("线程[" + Thread.currentThread().getName() + "]获取了锁...");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {//在finally代码块中是否锁
lock.unlock();
System.out.println("线程[" + Thread.currentThread().getName() + "]释放了锁..");
}
}).start();
//线程2通过lock.tryLock()尝试去获取一次锁
new Thread(() -> {
System.out.println("线程[" + Thread.currentThread().getName() + "]通过lock.tryLock()尝试去获取一次锁");
if (lock.tryLock()) {
System.out.println("线程[" + Thread.currentThread().getName() + "]获取了锁...");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
System.out.println("线程[" + Thread.currentThread().getName() + "]释放了锁..");
}
} else {
System.out.println("线程[" + Thread.currentThread().getName() + "]尝试获取锁失败，不再等待.");
}
}).start();
//线程3通过lock.tryLock(long,TimeUnit)尝试在一定时间内去获取锁
new Thread(() -> {
System.out.println("线程[" + Thread.currentThread().getName() + "]通过lock.tryLock(long,TimeUnit)尝试在一定时间内去获取锁");
try {
if (lock.tryLock(2, TimeUnit.SECONDS)) {
System.out.println("线程[" + Thread.currentThread().getName() + "]获取了锁...");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
System.out.println("线程[" + Thread.currentThread().getName() + "]释放了锁..");
}
} else {
System.out.println("线程[" + Thread.currentThread().getName() + "]在指定时间内没有获取到锁，不再等待.");
}
} catch (InterruptedException e) {
//e.printStackTrace(); 被中断时会产生的意料之中的错误，无需打印
System.out.println("线程[" + Thread.currentThread().getName() + "]被thread.interrupt()中断，不在尝试去获取锁");
}
}).start();
//线程4通过lock.lockInterruptibly()尝试可中断的去获取锁
Thread thread4 = new Thread(() -> {
try {
System.out.println("线程[" + Thread.currentThread().getName() + "]通过lock.lockInterruptibly()尝试可中断的去获取锁");
lock.lockInterruptibly();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
System.out.println("线程[" + Thread.currentThread().getName() + "]释放了锁..");
}
} catch (InterruptedException e) {
//e.printStackTrace(); 被中断时会产生的意料之中的错误，无需打印
System.out.println("线程[" + Thread.currentThread().getName() + "]被thread.interrupt()中断，不在尝试去获取锁");
}
});
thread4.start();
Thread.sleep(3000);
thread4.interrupt();
}
}

运行结果：

线程[Thread-0]尝试获取锁
线程[Thread-0]获取了锁...
线程[Thread-2]通过lock.tryLock()尝试去获取一次锁
线程[Thread-4]通过lock.lockInterruptibly()尝试可中断的去获取锁
线程[Thread-3]通过lock.tryLock(long,TimeUnit)尝试在一定时间内去获取锁
线程[Thread-1]通过lock.lock()持续去尝试获取锁
线程[Thread-2]尝试获取锁失败，不再等待.
线程[Thread-3]在指定时间内没有获取到锁，不再等待.
线程[Thread-4]被thread.interrupt()中断，不在尝试去获取锁
线程[Thread-1]获取了锁...
线程[Thread-0]释放了锁..
线程[Thread-1]释放了锁..

运行结果与预估一样。

4.总结

下面对上述的5个方法进行一句话总结：

lock()：获取锁，不可中断、不可超时。

lockInterruptibly()：获取锁，可以中断、不可超时。

trylock()：获取当前可用的锁并返回true，否则返回false，无需中断、无需超时。

tryLock(long time, TimeUnit unit)：获取限定时间可用的锁并返回true，否则返回false，可以中断、可以超时。

unlock()：解锁。