Java多线程--12 Lock、ReentrantLock等相关锁
1、Lock
Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。
锁是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问。一次只能有一个线程获得锁，对共享资源的所有访问都需要首先获得锁。不过，某些锁可能允许对共享资源并发访问，如 ReadWriteLock 的读取锁。
synchronized 方法或语句的使用提供了对与每个对象相关的隐式监视器锁的访问，但却强制所有锁获取和释放均要出现在一个块结构中：当获取了多个锁时，它们必须以相反的顺序释放，且必须在与所有锁被获取时相同的词法范围内释放所有锁。虽然 synchronized 方法和语句的范围机制使得使用监视器锁编程方便了很多，而且还帮助避免了很多涉及到锁的常见编程错误，但有时也需要以更为灵活的方式使用锁。例如，某些遍历并发访问的数据结果的算法要求使用 "hand-over-hand" 或 "chain locking"：获取节点 A 的锁，然后再获取节点 B 的锁，然后释放 A 并获取 C，然后释放 B 并获取 D，依此类推。Lock 接口的实现允许锁在不同的作用范围内获取和释放，并允许以任何顺序获取和释放多个锁，从而支持使用这种技术。
随着灵活性的增加，也带来了更多的责任。不使用块结构锁就失去了使用 synchronized 方法和语句时会出现的锁自动释放功能。在大多数情况下，应该使用以下语句：
Lock lock = new XxxLock() ;
lock.lock();
try {
// access the resource protected by this lock
} finally {
lock.unlock();
}
锁定和取消锁定出现在不同作用范围中时，必须谨慎地确保保持锁定时所执行的所有代码用 try-finally 或 try-catch 加以保护，以确保在必要时释放锁。
2、ReentrantLock
ReentrantLock（可重入锁），也叫做递归锁，当一个线程请求得到一个对象锁后再次请求此对象锁，可以再次得到该对象锁。
ReentrantLock 构造函数中提供了两种锁：创建公平锁和非公平锁（默认）。当参数设置为 true 时，在多个线程的争用下，这些锁倾向于将访问权授予等待时间最长的线程。否则此锁将无法保证任何特定访问顺序。（在公平的锁上，线程按照请求的顺序获取锁，FIFO 先进先出顺序，但在非公平锁上，则允许插队）
与采用默认设置（使用不公平锁）相比，使用公平锁的程序在许多线程访问时表现为很低的总体吞吐量（即速度很慢，常常极其慢），但是在获得锁和保证锁分配的均衡性时差异较小。不过要注意的是，公平锁不能保证线程调度的公平性。因此，使用公平锁的众多线程中的一员可能获得多倍的成功机会，这种情况发生在其他活动线程没有被处理并且目前并未持有锁时。还要注意的是，未定时的 tryLock 方法并没有使用公平设置。因为即使其他线程正在等待，只要该锁是可用的，此方法就可以获得成功。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockDemo implements Runnable {
private ReentrantLock lock;
public ReentrantLockDemo(ReentrantLock lock) {
this.lock = lock;
}
@Override
public void run() {
try {
System.out.println("当前线程:" + Thread.currentThread().getName() + "准备获取锁..");
lock.lock(); // 获取锁
System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method..");
Thread.sleep(1000);
System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method..");
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();// 释放锁
}
}
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
ExecutorService threadPools = Executors.newFixedThreadPool(2);
// 第一个线程需要释放锁后，第二个线程才能执行，否则永久处于线程阻塞状态。
threadPools.execute(new ReentrantLockDemo(lock));
threadPools.execute(new ReentrantLockDemo(lock));
threadPools.shutdown();
}
}
当前线程:pool-1-thread-2准备获取锁..
当前线程:pool-1-thread-1准备获取锁..
当前线程:pool-1-thread-2进入method..
当前线程:pool-1-thread-2退出method..
当前线程:pool-1-thread-1进入method..
当前线程:pool-1-thread-1退出method..
2.1、可重入锁
“可重入”是指任意线程在获取到锁之后，再次获取该锁而不会被该锁所阻塞。关联一个线程持有者+计数器，重入意味着锁操作的颗粒度为“线程”。
1、 线程再次获取锁：锁需要识别获取锁的现场是否为当前占据锁的线程，如果是，则再次成功获取；
2、锁的最终释放：线程重复n次获取锁，随后在第n次释放该锁后，其他线程能够获取该锁。要求对锁对于获取进行次数的自增，计数器对当前锁被重复获取的次数进行统计，当锁被释放的时候，计数器自减，当计数器值为0时，表示锁成功释放。
import java.util.concurrent.locks.ReentrantLock;
/**
* lock.getHoldCount()方法：只能在当前调用线程内部使用，不能再其他线程中使用
* 那么我可以在m1方法里去调用m2方法，同时m1方法和m2方法都持有lock锁定即可 测试结果holdCount数递增
*
*/
public class LockCountDemo {
//重入锁
private ReentrantLock lock = new ReentrantLock();
public void m1(){
try {
lock.lock();
System.out.println("进入m1方法，holdCount数为：" + lock.getHoldCount());
//调用m2方法
m2();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
System.out.println("m1方法 end，holdCount数为：" + lock.getHoldCount());
}
public void m2(){
try {
lock.lock();
System.out.println("进入m2方法，holdCount数为：" + lock.getHoldCount());
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
System.out.println("m2方法 end，holdCount数为：" + lock.getHoldCount());
}
public static void main(String[] args) {
LockCountDemo thc = new LockCountDemo();
thc.m1();
}
}进入m1方法，holdCount数为：1
进入m2方法，holdCount数为：2
m2方法 end，holdCount数为：1
m1方法 end，holdCount数为：0
3、ReentrantReadWriteLock
可重入读写锁。
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock()；
// 获取读取锁，是多个线程共享锁，允许对共享资源并发访问
ReadLock readLock = rwLock.readLock();
// 获去写入锁，是一个互斥锁，一个时刻只能有一个线程获取该锁。
WriteLock writeLock = rwLock.writeLock();
读取锁和写入锁是互斥的，同一时刻只能读或只能写
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
public class UseReentrantReadWriteLock {
//
private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
// 多个线程可以同时获取read锁 , public Condition newCondition() 因为 ReadLocks 不支持条件，所以将抛出 UnsupportedOperationException。
private ReadLock readLock = rwLock.readLock();
// 只能有1个线程同时获取write锁
private WriteLock writeLock = rwLock.writeLock();
public void read() {
try {
/**
* public void lock()
* 获取读取锁。如果另一个线程没有保持写入锁，则获取读取锁并立即返回，
* （即 如果另一个线程保持读取锁，当前线程仍可以获得读取锁）
* 如果另一个线程保持该写入锁，出于线程调度目的，将禁用当前线程，并且在获取读取锁之前，该线程将一直处于休眠状态。
*/
readLock.lock();
System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...read");
Thread.sleep(3000);
System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...read");
} catch (Exception e) {
e.printStackTrace();
} finally {
readLock.unlock();
}
}
public void write() {
try {
writeLock.lock();
System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...write");
Thread.sleep(3000);
System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...write");
} catch (Exception e) {
e.printStackTrace();
} finally {
writeLock.unlock();
}
}
public static void main(String[] args) {
final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
urrw.read();
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
urrw.read();
}
}, "t2");
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
urrw.write();
}
}, "t3");
Thread t4 = new Thread(new Runnable() {
@Override
public void run() {
urrw.write();
}
}, "t4");
t1.start();
t2.start();
t3.start();
t4.start();
}
}t1和t2先启动：
当前线程:t1进入...read
当前线程:t2进入...read
当前线程:t1退出...read
当前线程:t2退出...read
当前线程:t3进入...write
当前线程:t3退出...write
当前线程:t4进入...write
当前线程:t4退出...write
t3和t4先启动：
当前线程:t4进入...write
当前线程:t4退出...write
当前线程:t3进入...write
当前线程:t3退出...write
当前线程:t1进入...read
当前线程:t2进入...read
当前线程:t1退出...read
当前线程:t2退出...read
读的时候不能写，写的时候不能读；只能一个线程同时写，但是可以多个线程一起读。
