什么是Lock锁？
Lock锁提供了的比synchronized关键字更加灵活的锁操作，是代码层面的锁操作。
为什么要使用Lock锁？
Lock锁和synchronized关键字的对比
| 类型 | synchronized关键字 | Lock锁 |
|---|---|---|
| 获取锁 | 无超时时间，未获取到则阻塞等待（占用cpu资源），且无法被中断 | 非阻塞，可以被中断，未获取到则排队，中断，可以自定义超时时间 |
| 共享锁 | 不支持 | 读写锁ReadWriteLock支持 |
| 释放锁 | 必须在当前代码块中，因为synchronized是以{}来锁住共享资源的 | 可以在任意位置释放锁(其他方法或者其他类) |
概念普及
公平锁：保证每个线程都能获取到锁（排队先进来的先获取到锁），能够避免线程饥饿
非公平锁：谁抢到就是谁的，抢不到就排队
悲观锁：每次更新和读取都加锁，对于读多写少这种场景不利，适用于于写多读少的场景
乐观锁：更新失败则重试，适用一个标记位来控制，适用于多读的场景。
可重入锁：同一线程多次进入无需重新获取锁
共享锁（读锁）：一个锁可以同时被多个线程拥有,ReentrantReadWriteLock的读锁为共享锁，写锁为排他锁
排他锁（写锁）：独占锁，一个锁在某一时刻只能被一个线程占有，其它线程必须等待锁被释放之后才可能获取到锁，ReentrantLock就是排他锁。
如何使用？
public class LockTest {
// 这个必须放在成员变量或者作为方法参数进行传递。具体原因见后面代码分析
private final Lock lock = new ReentrantLock();
// 共享资源a
private int a = 0;
public static void main(String[] args) throws InterruptedException {
LockTest lockTest = new LockTest();
for (int i = 0; i < 10; ++i) {
// 模拟10个线程对 a进行++
new Thread(() -> {
for (int j = 0; j < 10000; ++j) {
lockTest.testLock();
}
}).start();
}
// 防止因为主线程结束，导致程序运行失败
Thread.sleep(5000);
System.out.println(lockTest.a);
}
public void testLock() {
try {
// 这块加锁也应该放到for循环外面。放里面会有性能问题。每+1就释放锁，
// 正常用该是+n然后等待cpu调度，然后释放锁
lock.lock();
++a;
} finally {
lock.unlock();
}
}
}
类功能分析
lock所有相关的代码都在java.utils.concurrent.locks这个包下。其中Lock和ReadWriteLock接口类是对外暴露的api
涉及到的设计模式：模板设计模式，组合模式
AbstractOwnableSynchronizer：AbstractQueuedSynchronizer的父类，仅仅是为了让子类能够设置和获取独占线程。
public abstract class AbstractOwnableSynchronizer {
protected AbstractOwnableSynchronizer() { }
private transient Thread exclusiveOwnerThread;
protected final void setExclusiveOwnerThread(Thread thread) {
exclusiveOwnerThread = thread;
}
protected final Thread getExclusiveOwnerThread() {
return exclusiveOwnerThread;
}
}
AbstractQueuedSynchronizer：提供了对Lock接口中，lock，tryLock()，unlock（），等方法的通用实现和通用方法（模板设计模式），相当于是一个工具类。
对于每一种锁，lock，tryLock，unlock又有其不同的实现。所以对于每一种Lock锁的实现，都会定义一个Sync的内部类。来实现其特有功能。
例如ReentrantLock类的实现如下。ReentrantLock的lock，tryLock等方法都是调用其内部类Sync的方法。
public class ReentrantLock implements Lock {
private final Sync sync;
abstract static class Sync extends AbstractQueuedSynchronizer {
// 由两个子类（FairSync和NonfairSync）来实现。
// 非公平锁直接使用cas抢（设置锁标志位为1），抢不到就按照正常的流程来（排队，先进先出（先等待的先获取到锁））
// 公平锁走正常流程（排队，先进先出）
abstract void lock();
final boolean nonfairTryAcquire(int acquires) {
// ...
}
protected final boolean tryRelease(int releases) {
// ...
}
protected final boolean isHeldExclusively() {
// ...
}
}
public void lock() {
// 调用内部类Sync的实现
sync.lock();
}
public void lockInterruptibly() throws InterruptedException {
// 调用内部类Sync的实现
sync.acquireInterruptibly(1);
}
public boolean tryLock() {
// 调用内部类Sync的实现
return sync.nonfairTryAcquire(1);
}
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
// 调用内部类Sync的实现
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
public void unlock() {
// 调用内部类Sync的实现
sync.release(1);
}
}
从上面的实现可以看出，如果Sync类是public的。我们其实可以直接使用Sync类来进行并发编程。使用Lock接口来包装一层只是让我们使用更加方便而已。
LockSupport类：工具类，方法都是public static的。用于挂起，恢复一个线程。
public class LockSupport {
private LockSupport() {} // Cannot be instantiated.
private static void setBlocker(Thread t, Object arg) {
// Even though volatile, hotspot doesn't need a write barrier here.
UNSAFE.putObject(t, parkBlockerOffset, arg);
}
// 恢复线程
public static void unpark(Thread thread) {
if (thread != null)
UNSAFE.unpark(thread);
}
// 挂起线程
public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
UNSAFE.park(false, 0L);
setBlocker(t, null);
}
public static void parkNanos(Object blocker, long nanos) {
if (nanos > 0) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
UNSAFE.park(false, nanos);
setBlocker(t, null);
}
}
public static void parkUntil(Object blocker, long deadline) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
UNSAFE.park(true, deadline);
setBlocker(t, null);
}
public static Object getBlocker(Thread t) {
if (t == null)
throw new NullPointerException();
return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
}
ReentrantLock源码剖析
private final Lock lock = new ReentrantLock();
lock加锁
// 默认为非公平锁
public ReentrantLock() {
// NonfairSync是Sync的一个实现类，实现了他的lock方法
sync = new NonfairSync();
}
ReentrantLock#lock方法调用的是其内部类Sync的lock方法
public void lock() {
// 由于默认为非公平锁，所有这里调用的是NonfairSync的lock方法
sync.lock();
}
NonfairSync类
static final class NonfairSync extends Sync {
final void lock() {
// 使用cas加锁(如果state等于0则设置为1返回true，否则返回false)，
// 只有没有任何线程持有锁时，这里才会返回true
if (compareAndSetState(0, 1))
// 加锁成功则设置独占线程为当前线程
setExclusiveOwnerThread(Thread.currentThread());
else
// 加锁失败则调用AbstractQueuedSynchronizer类的acquire方法
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
// 调用父类Sync的nonfairTryAcquire方法
return nonfairTryAcquire(acquires);
}
}
// AbstractQueuedSynchronizer类的acquire方法
public final void acquire(int arg) {
// 调用NonfairSync类的tryAcquire方法
if (!tryAcquire(arg) &&
// 如果tryAcquire返回false，加锁失败则进行排队
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
// 两个都是false。则当前线程请求锁失败，中断自己。
selfInterrupt();
}
// Sync类
abstract static class Sync extends AbstractQueuedSynchronizer {
abstract void lock();
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 获取当前锁状态
int c = getState();
if (c == 0) {
// 为0则表示锁是空闲状态，则加锁
if (compareAndSetState(0, acquires)) {
// 设置独占线程为自己
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
// 如果自己就是独占线程，则只是将锁的状态标志位+1
// acquires外部传的是1，一般也不会出现其他数字
// 这里就是锁的可重入实现。只是增加状态值，释放锁时再减状态值。
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
// 设置状态为 state += 1，这里不会出现线程安全问题，因为锁被自己占有
// 所以直接调用setState方法，而不是调用compareAndSetState(c, acquires)方法。
setState(nextc);
return true;
}
return false;
}
}
unlock解锁
lock.unlock();
解锁同样调用的是Sync的实现，数字1代表锁的标志位state - 1，因为之前在加锁时，会将state + 1；
public void unlock() {
sync.release(1);
}
Sync类中并没有实现release方法，因为所有锁的释放操作其实都是一样的，所以这里调用的是父类AbstractQueuedSynchronizer的release方法
AbstractQueuedSynchronizer#release
// 释放锁
public final boolean release(int arg) {
// 调用Sync类的tryRelease方法
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
// 如果有线程在等待锁释放，则将该线程恢复
unparkSuccessor(h);
// 没有线程在等待资源，则直接返回true
return true;
}
return false;
}
// 返回当前锁的状态（true空闲，false，表示当前线程多次获取锁，是重入状态）
protected final boolean tryRelease(int releases) {
// 锁的状态标志位-1
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
// 设置独占线程为空
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
扫一扫
484
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
