Java学习笔记8-锁相关
Java中锁的概念
自旋锁：为了不放弃CPU执行时间，循环的使用CAS机制对数据尝试进行更新，直至成功。
悲观锁：假定会发生并发冲突，同步所有对数据的相关操作，从读取数据开始就上锁。
乐观锁：假定没有冲突，在写入数据时如果发现数据和之前读取的不一致，则获取最新数据，然后重试更新。
独享锁（写）：给资源加上写锁，线程可以修改资源，其它线程不能再加锁。（单写）
共享锁（读）：给资源加上读锁后只能读不能改，其他线程也只能加读锁，不能加写锁。（多读）
可重入锁、不可重入锁：线程拿到一把锁之后，可以自由进入同一把锁同步的其他代码，即为可重入。
公平锁、非公平锁：争抢锁的顺序，如果是按先来后到，则为公平。
几种重要的锁实现方式：synchronized、ReentrantLock、ReentrantReadWriteLock
同步关键字synchronized
属于最基本的线程通信机制，基于对象监视器（Monitor）实现的。
Java中的每个对象都与一个监视器相关联，一个线程可以锁定或解锁。
一次只有一个线程可以锁定监视器。
试图锁定该监视器的任何其他线程都会被阻塞，直到它们可以获得该监视器上的锁为止。
特性：可重入、独享、悲观锁
锁的范围：类锁、对象锁、锁消除（JDK6以上）、锁粗化（JDK6以上）
提示：同步关键字，不仅是实现同步，根据 JVM规范还能保证可见性（读取最新主内存数据，结束后写入主内存）。
同步关键字加锁原理
在HotSpot中，对象前面会有一个类指针和标题的Mark World，存储标识哈希码的标题字以及用于分代垃圾回收的年龄和标记位。
默认情况下JVM锁会经历：无锁 / 偏向锁 -> 轻量级锁 -> 重量级锁 -> GC标记 这四种状态
| Mark World |
|---|
| Class Metadata Address |
| Array Length |
Mark World 存储结构：
| Bitfields | Tag | State |
|---|---|---|
| Hashcode | Age | 0 | 01 | Unlocked |
| Lock record address | 00 | Light-weight locked |
| Monitor address | 10 | Heavy-weight locked |
| Forwarding address,etc. | 11 | Marked for GC |
| Thread ID | Age | 1 | 01 | Biased / Biasable |
参考来源：https://www.cs.princeton.edu/picasso/mats/HotspotOverview.pdf
锁升级过程
-
无锁 / 偏向锁：JVM默认开启偏向锁（可以设置关闭），偏向锁标志位：1（开启），状态位：01
单个线程获取锁时，没有竞争，直接将Thread ID设为自己的ID，即为获取到锁。
| Bitfields | Tag（State） |
|---|---|
| Hashcode | Age | 0 | 01（Unlocked） |
| Thread ID | Age | 1 | 01（Biased / Biasable） |
-
轻量级锁：状态位：00
当发生多个线程去争抢时，锁升级为轻量级锁，通过CAS机制去修改状态。
| Bitfields | Tag（State） |
|---|---|
| Lock record address | 00（Light-weight locked） |
-
重量级锁：状态位：10
通过CAS机制去修改状态，自旋失败一定次数，锁升级为重量级锁，变为对象监视器锁进入阻塞。
| Bitfields | Tag（State） |
|---|---|
| Monitor address | 10（Heavy-weight locked） |
监视器（Monitor ）构造
-
monitorenter 进入 --进入争抢集合–> 2
-
_EntryList 争抢集合（锁池） --争抢锁–> 3
-
_owner（锁的拥有者） --wait 释放-等待–> 4
--释放-退出–> 5
-
_WaitSet 等待集合（等待池） --notify 争抢锁–> 3
-
monitorexit 退出
Lock的核心API
| 方法 | 描述 |
|---|---|
| lock | 获取锁的方法，若锁被其他线程获取，则等待（阻塞） |
| lockInterruptibly | 在锁的获取过程中可以中断当前线程 |
| tryLock | 尝试非阻塞地获取锁，立即返回 |
| unlock | 释放锁 |
提示：根据Lock接口的源码注释，Lock接口的实现，具备和同步关键字同样的内存语义。
ReentrantLock：可重入锁
线程拿到一把锁之后，可以自由进入同一把锁同步的其他代码，即为可重入。 直接上代码演示……
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockTest {
private static final ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
lock.lock();
System.out.println(Thread.currentThread().getName() + "获取锁的次数 " + lock.getHoldCount());
try {
lock.lock();
System.out.println(Thread.currentThread().getName() + "获取锁的次数 " + lock.getHoldCount());
} finally {
//lock.unlock();
lock.unlock();
}
System.out.println(Thread.currentThread().getName() + "获取锁的次数 " + lock.getHoldCount());
// 若不释放锁，其他线程是抢不到锁的
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " 期望抢到锁");
lock.lock();
System.out.println(Thread.currentThread().getName() + " 抢到了锁");
}).start();
}
}
抢到锁的线程可以继续获取锁，只有把所有锁都释放了，其他线程才可以抢到锁。
ReadWriteLock：读写锁
管理一对关联锁，一个用于读取，一个用于写入；读锁可以由多个读取线程同时持有，写锁是排他的。
适合读取线程比写入线程多的场景，改进互斥锁的性能，示例场景：缓存组件、集合的并发线程安全性改造。
锁降级指的是写锁降级成为读锁。在持有当前写锁的同时，再获取到读锁，随后释放写锁的过程。
写锁是线程独占，读锁是共享，所以写锁 -> 读锁 为降级。（读锁 -> 写锁 是不能实现的）
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockTest {
ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
/**
* 可多个线程读取，共享锁
*
* @param thread
*/
public void read(Thread thread) {
readWriteLock.readLock().lock();
try {
long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName() + "正在进行“读”操作");
}
System.out.println(thread.getName() + "“读”操作完毕");
} finally {
readWriteLock.readLock().unlock();
}
}
/**
* 只能单个线程写入，独占锁
*
* @param thread
*/
public void write(Thread thread) {
readWriteLock.writeLock().lock();
try {
long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName() + "正在进行“写”操作");
}
System.out.println(thread.getName() + "“写”操作完毕");
} finally {
readWriteLock.writeLock().unlock();
}
}
public static void main(String[] args) {
ReadWriteLockTest readWriteLockTest = new ReadWriteLockTest();
// 多线程同时读/写
new Thread(() -> {
readWriteLockTest.read(Thread.currentThread());
}).start();
new Thread(() -> {
readWriteLockTest.read(Thread.currentThread());
}).start();
new Thread(() -> {
readWriteLockTest.write(Thread.currentThread());
}).start();
}
}
锁降级测试代码
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class LockDownTest {
// 创建一个map用于缓存
private Map<String, Object> map = new HashMap<>();
private static ReadWriteLock rwl = new ReentrantReadWriteLock();
public Object get(String id) {
Object value = null;
// 首先开启读锁，从缓存中去取
rwl.readLock().lock();
try {
if ((value = map.get(id)) == null) {
// TODO database.query(); 全部查询数据库，缓存雪崩
// 必须释放读锁
rwl.readLock().unlock();
// 如果缓存中没有，释放读锁上写锁。如果不加锁，所有请求全部去查询数据库，就崩溃了
rwl.writeLock().lock(); // 所有线程在此处等待 1000 1 999 (在同步代码里面再次检查是否缓存)
try {
// 双重检查，防止已经有线程改变了当前的值，从而出现重复处理的情况
if ((value = map.get(id)) == null) {
// TODO value = ...如果缓存没有，就去数据库里面读取
// value = database.query();
// put 放置到缓存
}
rwl.readLock().lock(); // 加读锁降级写锁，这样就不会有其他线程能够改这个值，保证了数据一致性
} finally {
rwl.writeLock().unlock(); // 释放写锁
}
}
} finally {
rwl.readLock().unlock();
}
return value;
}
public static void main(String[] args) {
// 1 读取缓存里面的数据 cache.query()
// 2 如果缓存没数据，则去数据库里面查询 database.query()
// 3 查询完成之后，将结果放到缓存里面 cache.put(data)
new LockDownTest().get("key1");
}
}
实现自己的锁
了解了一些Lock原理，下面我们来实现个简易的锁
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
public class MyLockTest implements Lock {
// 当前锁的拥有者
volatile AtomicReference<Thread> owner = new AtomicReference<>();
// 等待集合（锁池）
volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();
/**
* 尝试获取一次锁
*
* @return
*/
@Override
public boolean tryLock() {
return owner.compareAndSet(null, Thread.currentThread());
}
/**
* 获取锁
*/
@Override
public void lock() {
boolean addQ = true;
while (!tryLock()) {
if (addQ) {
// 没获取到锁，加入到等待集合中
waiters.offer(Thread.currentThread());
addQ = false;
} else {
// 挂起当前线程，等待其他线程释放
LockSupport.park(); // 收到 unpark 通知之后唤醒，继续循环
}
}
waiters.remove(Thread.currentThread()); // 从等待集合中移除线程
}
/**
* 释放锁
*/
@Override
public void unlock() {
// CAS 修改 owner 拥有者
if (owner.compareAndSet(Thread.currentThread(), null)) {
// 通知其他等待线程
Iterator<Thread> iterator = waiters.iterator();
while (iterator.hasNext()) {
Thread waiter = iterator.next();
LockSupport.unpark(waiter); // 唤醒线程继续 抢锁
}
}
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public Condition newCondition() {
return null;
}
}
扫一扫
947
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
