Java 锁介绍及使用场景

待我称王封你为后i 2024-03-26 23:19 122阅读 0赞

### 一、悲观锁和乐观锁 ###

#### 1.基本概念 ####

乐观锁和悲观锁是两种思想，用来解决并发场景下的数据竞争问题。

乐观锁：乐观锁在操作数据非常乐观，认为别人不会同时修改数据，所以一般在更新数据的时候判断当前的值是否被修改过，如果被修改过就放弃操作，没有修改过就执行操作。

悲观锁：悲观锁在操作数据时非常悲观，认为别人会同时操作该数据，所以在操作数据的时候会带上锁，直到操作完成后才放开锁，在锁未释放之前其他人不能操作此数据。

#### 2.实现方式(含实例) ####

在介绍实现方式之前，**需要明确：乐观锁和悲观锁是一种思想，不限制于任何一种数据库或编程语言。**

乐观锁的实现方式主要是两种：CAS 操作和版本号机制

悲观锁的方式是加锁，加锁既可以对代码块(Synchronize)加锁，也可以对数据进行加锁(MySQL 的排它锁)

具体的实现方式下面详细介绍.

##### 1) CAS(Compare And Swap) #####

CAS 操作包含 3 个操作数：

*  需要读写的内存位置 V
 *  进行比较的预期值 A
 *  需要写入的最新值 B

CAS 操作逻辑如下：如果内存位置的 V 的值等于预期的 A 值，就将该位置更新为新值 B，否则不进行任何操作。许多 CAS 的操作是自旋的：如果操作不成功，会一直重试，直到操作成功为止。

CAS 相关的详细介绍：[https://www.vnjohn.com/what-is-cas-html/][https_www.vnjohn.com_what-is-cas-html]

##### 2) 版本号机制 #####

除了 CAS，版本号也可以实现乐观锁。版本号的基础思路就是在数据库中添加 version 字段，表示该数据的版本号，如果该数据被修改成功，版本号就 +1，当某个线程查询数据的时候，判断当前的版本号与之前的数据库版本号是否一致，如果一致才进行操作。

需要注意的是，这里使用了版本号作为判断数据变化的标记，实际上可以根据实际情况选用其他能够标记数据版本的字段，如时间戳等。

下面以“更新玩家金币数”为例(数据库为 MySQL，其他数据库同理)，看看悲观锁和版本号机制是如何应对开发问题的。

考虑这样一种场景：游戏系统需要更新玩家的金币数，更新后的金币数依赖于当前状态(如金币数、等级等)，因此更新前需要先查询玩家当前状态。

下面的实现方式，没有进行任何线程安全方面的保护。如果有其他线程 query 和 update 之间更新了玩家的信息，会导致玩家金币数的不准确。

@Transactional
    public void updateCoins(Integer playerId){
        //根据 player_id 查询玩家信息
        Player player = query("select coins, level from player where player_id = {0}", playerId);
        //根据玩家当前信息及其他信息，计算新的金币数
        Long newCoins = ……;
        //更新金币数
        update("update player set coins = {0} where player_id = {1}", newCoins, playerId);
    }

为了避免这个问题，悲观锁通过加锁解决这个问题，代码如下所示：在查询玩家信息时，使用 select ... for update 进行查询，该查询语句会为该玩家数据加上排它锁，直到事务提交或回滚时才会释放排它锁，在此期间，如果其他线程试图更新该玩家信息或者执行 select for update，会被阻塞。

@Transactional
    public void updateCoins(Integer playerId){
        //根据player_id查询玩家信息(加排它锁)
        Player player = queryForUpdate("select coins, level from player where player_id = {0} for update", playerId);
        //根据玩家当前信息及其他信息，计算新的金币数
        Long newCoins = ……;
        //更新金币数
        update("update player set coins = {0} where player_id = {1}", newCoins, playerId);
    }

版本号机制则是另一种思路，它为玩家信息增加一个字段：version。在初次查询玩家信息时，同时查询出 version 信息；在执行 update 时，检验 version 是否发生了变化，如果 version 变化，则不进行更新。

@Transactional
    public void updateCoins(Integer playerId){
        //根据player_id查询玩家信息，包含version信息
        Player player = query("select coins, level, version from player where player_id = {0}", playerId);
        //根据玩家当前信息及其他信息，计算新的金币数
        Long newCoins = ……;
        //更新金币数，条件中增加对version的校验
        update("update player set coins = {0}, version = version + 1 where player_id = {1} and version = {2}", newCoins, playerId, player.version);
    }

#### 3.优缺点和适用场景 ####

乐观锁和悲观锁并没有优劣之分，它们有各自适合的场景；下面从两个方面进行说明。

##### 1) 功能限制 #####

与悲观锁相比，乐观锁适用的场景受到了更多的限制，无论是 CAS 还是版本号机制

例如，CAS 只能保证单个变量操作的原子性，当涉及到多个变量时，CAS 还是无能为力的，而 synchronize 则可以通过对整个代码块加锁来处理，再比如版本号机制，如果 query 的时候是针对表 1，而 update 的时候是针对表 2，也很难通过简单的版本号来实现乐观锁。

##### 2) 竞争激烈程度 #####

如果悲观锁和乐观锁都可以使用，那么选择就要考虑竞争的激烈程序：

*  当竞争不激烈(出现并发冲突的概率小)时，乐观锁更有优势，因为悲观锁会锁住代码块或数据，其他线程无法同时访问，影响并发，而且加锁和释放锁都需要消耗额外的资源。
 *  当竞争激烈(出现并发冲突的概率大)时，悲观锁更有优势，因为乐观锁在执行更新时频繁失败，需要不断重试，浪费 CPU 资源。

#### 4.面试官追问：乐观锁加锁吗？ ####

*  乐观锁本身是不加锁的，只是在更新时判断一下数据是否被其他线程更新了；AtomicInteger 便是一个例子。
 *  有时候了乐观锁可能与加锁操作合作，例如：在前述 updateConins() 的例子中，MySQL 在执行 update 时会加排它锁，但这只是乐观锁与加锁操作合作的例子，不能改变“乐观锁本身不加锁”这一事实。

### 二、公平锁和非公平锁 ###

#### 1.基本概念 ####

公平锁：公平锁就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照 FIFO 的规则从队列中取到自己，是指多个线程按照申请锁的顺序来获取锁，类似排队打饭、先来后到

非公平锁：非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式，是指多线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取到锁，在高并发的情况下，有可能造成优先级反转或者饥饿现象。

**题外语：**

public ReentrantLock(boolean fair) {
            sync = fair ? new FairSync() : new NonfairSync();
     }

Java ReentrantLock 而言，通过以上构造函数 指定该锁是否是公平锁，默认是非公平锁，非公平锁的优点在于吞吐量比公平锁大，对于 synchronize 而言，也是一种非公平锁。

### 三、可重入锁(又名递归锁) ###

#### 1.基本概念 ####

可重入锁：指的是同一线程外层函数获取锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁，也就是说：**线程可以进行任何一个它已经拥有的锁所同步着的代码块。**

ReentrantLock/synchronize 就是一个典型的可重入锁，可重入锁的最大作用就是避免死锁。

#### 2.实现方式(含实例) ####

**ReentrantLock 实现方式：**

/**
     * @author vnjohn
     * @NAME: Phone
     * @DATE: 2020/12/5
     */
    public class Phone implements Runnable {
        private Lock lock = new ReentrantLock();
    
        @Override
        public void run() {
            get();
        }
    
        private void get() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\tget");
                set();
            } finally {
                lock.unlock();
            }
        }
    
        private void set() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\tset");
            } finally {
                lock.unlock();
            }
        }
    }

实现 Runnable 接口重写 run 方法在里面进行方法的调用，通过 ReentrantLock 加锁在代码块中调用另一个加锁的方法，不需要再次获取锁

/**
     * @author vnjohn
     * @NAME: ReenterLockDemo
     * @DATE: 2020/12/5
     */
    public class ReenterLockDemo {
        public static void main(String[] args) {
            Phone phone = new Phone();
            Thread t3 = new Thread(phone);
            Thread t4 = new Thread(phone);
            t3.start();
            t4.start();
        }
    }

执行结果如下：

[![alt][]

![alt][]][alt_ _alt]

**synchronize 实现方式：**

/**
     * @author vnjohn
     * @NAME: Phone
     * @DATE: 2020/12/5
     */
    public class Phone {
        public synchronized void sendSms() throws Exception{
            System.out.println(Thread.currentThread().getName()+"\tsendSms");
            sendEmail();
        }
        public synchronized void sendEmail() throws Exception{
            System.out.println(Thread.currentThread().getName()+"\tsendEmail");
        }
    }

两个方法都使用 synchronize 修饰加锁，看两个线程争抢锁是否会等待第一个线程将两个方法执行完再继续第二个线程的进行

/**
     * @author vnjohn
     * @NAME: ReenterLockDemo
     * @DATE: 2020/12/5
     */
    public class ReenterLockDemo {
        public static void main(String[] args) {
            Phone phone = new Phone();
            new Thread(()->{
                try {                
                    phone.sendSms();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },"t1").start();
    
            new Thread(()->{
                try {
                    phone.sendSms();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },"t2").start();
        }
    }

执行结果如下：

[![alt][alt 1]

![alt 1][]][alt_alt 1_ _alt 1]

### 四、自旋锁 ###

#### 1.基本概念 ####

自旋锁(spinlock) 是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处就是减少线程上下文切换的消耗，缺点就是循环会消耗 CPU。

// unsafe getAndAddInt
    public final int getAndAddInt(Object var1, long var2, int var4) {
            int var5;
            do {
                var5 = this.getIntVolatile(var1, var2);
            } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    
            return var5;
    }

#### 2.实现方式(含实例) ####

需求：实现一个自旋锁

自旋锁好处：循环比较获取直到成功，没有类似 wait 的阻塞，但长时间的循环会影响效率

/**
     * @author vnjohn
     * @NAME: SpinLockDemo
     * @DATE: 2020/12/5
     */
    public class SpinLockDemo {
        /** 原子引用线程*/
        AtomicReference<Thread> atomicReference = new AtomicReference<>();
    
        public void myLock() {
            Thread thread = Thread.currentThread();
            System.out.println(Thread.currentThread().getName() + "\t come in ^_^");
            while (!atomicReference.compareAndSet(null, thread)) {
    
            }
        }
    
        public void myUnLock() {
            Thread thread = Thread.currentThread();
            atomicReference.compareAndSet(thread, null);
            System.out.println(Thread.currentThread().getName() + "\t invoke myUnLock");
        }
    
        public static void main(String[] args) {
            SpinLockDemo spinLockDemo = new SpinLockDemo();
            new Thread(() -> {
                spinLockDemo.myLock();
                try {
                    //暂停一会儿线程
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                spinLockDemo.myUnLock();
            }, "A").start();
    
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            new Thread(() -> {
                spinLockDemo.myLock();
                try {
                    //暂停一会儿线程
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                spinLockDemo.myUnLock();
            }, "B").start();
        }
    }

执行结果如下：

[![alt][alt 2]

![alt 2][]][alt_alt 2_ _alt 2]

以上的执行逻辑大致如下：

*  A 线程先进去 myLock 方法进行 while 循环比较，此前 atomicReference 为 null，更换线程成功返回 false 跳出循环，睡眠 5 秒后再执行 myUnLock 方法，这个时候 atomicReference 又变为 null。
 *  B 线程后进去 myLock 方法进行 while 循环比较，此前 atomicReference 不为 null，一直在 while 循环里面进行自旋，等到 A 线程执行了 myLock 方法以后对象为 null，这个时候 B 线程再进行比较会返回 false，然后执行最后的 myUnLock 方法。

### 五、**独占锁(写)/共享锁(读)/互斥锁** ###

#### 1.基本概念 ####

独占锁：指该锁一次只能被一个线程所持有。对 ReentrantLock 和 synchronize 而言都是独占锁

共享锁：指该锁可以被多个线程所持有。

对 ReentrantReadWriteLock 其读锁是共享锁，其写锁是独占锁。

读锁的共享锁可以保证并发读是非常高效的，读写，写读，写写的过程时互斥的。

#### 2.实现方式(及其实例) ####

读写锁操作资源类 **ReentrantReadWriteLock**：

/**
     * @author vnjohn
     * @NAME: ReadWriteLockDemo
     * @DATE: 2020/12/5
     */
    public class ReadWriteLockDemo {
        /** 保证可见性 */
        private volatile Map<String, Object> map = new HashMap<>();
        private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    
        /**
         * 写
         * @param key
         * @param value
         */
        public void put(String key, Object value) {
            // 获取写锁
            reentrantReadWriteLock.writeLock().lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t正在写入" + key);
                //模拟网络延时
                try {
                    TimeUnit.MICROSECONDS.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                map.put(key, value);
                System.out.println(Thread.currentThread().getName() + "\t正在完成");
            } finally {
                reentrantReadWriteLock.writeLock().unlock();
            }
        }
    
        /**
         * 读
         * @param key
         */
        public void get(String key) {
            // 获取读锁
            reentrantReadWriteLock.readLock().lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t正在读取");
                //模拟网络延时
                try {
                    TimeUnit.MICROSECONDS.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Object result = map.get(key);
                System.out.println(Thread.currentThread().getName() + "\t正在完成" + result);
            } finally {
                reentrantReadWriteLock.readLock().unlock();
            }
        }
    
        public void clearCaChe() {
            map.clear();
        }
    
        public static void main(String[] args) {
            ReadWriteLockDemo myCaChe = new ReadWriteLockDemo();
            for (int i = 1; i <= 5; i++) {
                final int temp = i;
                new Thread(() -> {
                    myCaChe.put(temp + "", temp);
                }, "写入："+String.valueOf(i)).start();
            }
            for (int i = 1; i <= 5; i++) {
                int finalI = i;
                new Thread(() -> {
                    myCaChe.get(finalI + "");
                },"读取："+ String.valueOf(i)).start();
            }
        }
    }

执行结果如下：

[![alt][alt 3]

![alt 3][]][alt_alt 3_ _alt 3]

**简要描述如下：**

多个线程同时操作一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行，但是如果有一个线程想去写共享资源就不应该有其他线程可以对资源进行读或写。

**总结：读读能共存，读写不能共存，写写不能共存，写操作时原子+独占整个过程必须是一个完成的统一整体，中间不允许被分割，被打断。**

##### 参考文献 #####

[https://www.cnblogs.com/kismetv/p/10787228.html][https_www.cnblogs.com_kismetv_p_10787228.html]

下篇文章介绍：

**CountDownLatch/CyclicBarrier/Semaphore 并发工具类及其阻塞队列~~**

#### *相关* ####

[https_www.vnjohn.com_what-is-cas-html]: https://www.vnjohn.com/what-is-cas-html/
[alt]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/11/9cb6de15517b4c4d844ba1fb574361be.png
[alt_ _alt]: https://i0.wp.com/www.vnjohn.com/wp-content/uploads/2020/12/image-1.png?ssl=1
[alt 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/11/9c22144fa80d404cb86ffb440e3bc57f.png
[alt_alt 1_ _alt 1]: https://i0.wp.com/www.vnjohn.com/wp-content/uploads/2020/12/image.png?ssl=1
[alt 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/11/7bff8636fb87437da12f0ede46ae99e3.png
[alt_alt 2_ _alt 2]: https://i0.wp.com/www.vnjohn.com/wp-content/uploads/2020/12/image-2.png?ssl=1
[alt 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/11/601921506c124251a4beddf90e0a877a.png
[alt_alt 3_ _alt 3]: https://i0.wp.com/www.vnjohn.com/wp-content/uploads/2020/12/image-3.png?ssl=1
[https_www.cnblogs.com_kismetv_p_10787228.html]: https://www.cnblogs.com/kismetv/p/10787228.html