Java并发九 Lock

1.概述
简而言之，锁是一种比标准同步块更灵活，更复杂的线程同步机制。

自Java 1.5以来，Lock接口一直存在。它在java.util.concurrent.lock包中定义，它提供了大量的锁定操作。

在本文中，我们将探讨Lock接口及其应用程序的不同实现。

2. 锁定和同步 块之间的差异
   有使用同步之间的一些差异块，并使用锁 API的：

甲同步 块被完全包含在方法中-我们可以有锁 API的锁（）和解锁（）在单独的方法操作
s ynchronized块不支持公平性，任何线程一旦释放就可以获得锁定，不能指定任何偏好。通过指定公平属性，我们可以在Lock API中实现公平。它确保最长的等待线程可以访问锁
如果线程无法访问同步块，则会阻塞该线程。所述锁 API提供的tryLock（）方法。只有当线程可用且没有任何其他线程持有时，线程才会获取锁定。这减少了线程等待锁定的阻塞时间
处于“等待”状态以获取对同步块的访问的线程不能被中断。所述锁 API提供了一种方法的lockInterruptibly（） ，其可以用来中断线程时，它的等待锁
3. 锁定 API
我们来看看Lock界面中的方法：

void lock（） -获取锁定（如果可用）; 如果锁定不可用，则线程会被锁定，直到锁定被释放
void lockInterruptibly（） - 这类似于 lock（），但它允许被阻塞的线程被中断并通过抛出的 java.lang.InterruptedException恢复执行
boolean tryLock（） - 这是 lock（）方法的非阻塞版本; 它会立即尝试获取锁定，如果锁定成功则返回true
boolean tryLock（long timeout，TimeUnit timeUnit） -这类似于 tryLock（），除了它在放弃尝试获取 Lock之前等待给定的超时
void unlock（） - 解锁Lock实例
应始终解锁锁定的实例以避免死锁情况。使用锁的推荐代码块应包含try / catch和finally块：

1
2
3
4
5
6
7
Lock lock = ...; 
lock.lock();
try {
    // access to the shared resource
} finally {
    lock.unlock();
}

除了 Lock接口之外，我们还有一个ReadWriteLock接口，它维护一对锁，一个用于只读操作，另一个用于写操作。只要没有写入，读锁定可以由多个线程同时保持。

ReadWriteLock声明获取读或写锁的方法：

Lock readLock（） -返回用于读取的锁
Lock writeLock（） - 返回用于写入的锁
4. 锁定实现
4.1。ReentrantLock的
ReentrantLock类实现Lock接口。它提供了相同的并发和内存语义，如使用同步方法和语句访问的隐式监视器锁，具有扩展功能。

让我们看看，我们如何使用ReenrtantLock进行同步：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class SharedObject {
    //...
    ReentrantLock lock = new ReentrantLock();
    int counter = 0;
 
    public void perform() {
        lock.lock();
        try {
            // Critical section here
            count++;
        } finally {
            lock.unlock();
        }
    }
    //...
}

我们需要确保在try-finally块中包装lock（）和unlock（）调用以避免死锁情况。

让我们看看tryLock（）的工作原理：

1
2
3
4
5
6
7
8
9
10
11
12
13
public void performTryLock(){
    //...
    boolean isLockAcquired = lock.tryLock(1, TimeUnit.SECONDS);
     
    if(isLockAcquired) {
        try {
            //Critical section here
        } finally {
            lock.unlock();
        }
    }
    //...
}

在这种情况下，调用tryLock（）的线程将等待一秒钟，并且如果锁定不可用则放弃等待。

4.2。的ReentrantReadWriteLock
ReentrantReadWriteLock类实现ReadWriteLock接口。

让我们看一下线程获取ReadLock或WriteLock的规则：

读锁定 - 如果没有线程获得写锁定或请求它，则多个线程可以获取读锁定
写入锁定 - 如果没有线程正在读取或写入，则只有一个线程可以获取写入锁定
让我们看看如何使用ReadWriteLock：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class SynchronizedHashMapWithReadWriteLock {
 
    Map<String,String> syncHashMap = new HashMap<>();
    ReadWriteLock lock = new ReentrantReadWriteLock();
    // ...
    Lock writeLock = lock.writeLock();
 
    public void put(String key, String value) {
        try {
            writeLock.lock();
            syncHashMap.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }
    ...
    public String remove(String key){
        try {
            writeLock.lock();
            return syncHashMap.remove(key);
        } finally {
            writeLock.unlock();
        }
    }
    //...
}
对于这两种写入方法，我们需要使用写锁定来包围临界区，只有一个线程可以访问它：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Lock readLock = lock.readLock();
//...
public String get(String key){
    try {
        readLock.lock();
        return syncHashMap.get(key);
    } finally {
        readLock.unlock();
    }
}
 
public boolean containsKey(String key) {
    try {
        readLock.lock();
        return syncHashMap.containsKey(key);
    } finally {
        readLock.unlock();
    }
}

对于这两种读取方法，我们需要使用读锁定来包围临界区。如果没有正在进行写入操作，则多个线程可以访问此部分。

4.3。StampedLock
StampedLock在Java 8中引入。它还支持读写锁定。但是，锁定获取方法会返回一个用于释放锁定或检查锁定是否仍然有效的戳记：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class StampedLockDemo {
    Map<String,String> map = new HashMap<>();
    private StampedLock lock = new StampedLock();
 
    public void put(String key, String value){
        long stamp = lock.writeLock();
        try {
            map.put(key, value);
        } finally {
            lock.unlockWrite(stamp);
        }
    }
 
    public String get(String key) throws InterruptedException {
        long stamp = lock.readLock();
        try {
            return map.get(key);
        } finally {
            lock.unlockRead(stamp);
        }
    }
}

StampedLock提供的另一个功能是乐观锁定。大多数时候，读操作不需要等待写操作完成，因此不需要完全成熟的读锁。

相反，我们可以升级到读锁：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public String readWithOptimisticLock(String key) {
    long stamp = lock.tryOptimisticRead();
    String value = map.get(key);
 
    if(!lock.validate(stamp)) {
        stamp = lock.readLock();
        try {
            return map.get(key);
        } finally {
            lock.unlock(stamp);               
        }
    }
    return value;
}

5.使用条件
该条件类提供了一个线程等待在执行关键部分出现一些状况的能力。

当线程获得对临界区的访问但没有执行其操作的必要条件时，可能会发生这种情况。例如，读者线程可以访问共享队列的锁，该队列仍然没有任何数据要消耗。

传统上，Java 为线程互通提供了wait（），notify（）和notifyAll（）方法。条件有类似的机制，但另外，我们可以指定多个条件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class ReentrantLockWithCondition {
 
    Stack<String> stack = new Stack<>();
    int CAPACITY = 5;
 
    ReentrantLock lock = new ReentrantLock();
    Condition stackEmptyCondition = lock.newCondition();
    Condition stackFullCondition = lock.newCondition();
 
    public void pushToStack(String item){
        try {
            lock.lock();
            while(stack.size() == CAPACITY) {
                stackFullCondition.await();
            }
            stack.push(item);
            stackEmptyCondition.signalAll();
        } finally {
            lock.unlock();
        }
    }
 
    public String popFromStack() {
        try {
            lock.lock();
            while(stack.size() == 0) {
                stackEmptyCondition.await();
            }
            return stack.pop();
        } finally {
            stackFullCondition.signalAll();
            lock.unlock();
        }
    }
}