Java学习笔记8锁相关

Z时代
2024-01-10
分类：综合

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

Unlocked

Lock record address

Light-weight locked

Monitor address

Heavy-weight locked

Forwarding address,etc.

Marked for GC

Thread ID | Age | 1

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;
    }
}