乐观锁的思想和其在Java中的实现

川长思鸟来 2023-07-05 10:19 18阅读 0赞

首先我们要明白，所谓的乐观锁和悲观锁其实都是一种思想，基于思想，可以做出很多种实现。  
乐观锁与悲观锁的概念非常好理解。

## 悲观锁 ##

当一个公共变量（比如一个有状态的单例对象）被多个线程访问的时候，我们假设每个线程都会去修改这个公共变量，于是我们要让访问这个公共变量的线程上锁，这样其他线程要想访问这个变量就会阻塞等待锁的释放。这个就是悲观锁的思想。在关系型数据库中就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁也是悲观锁思想的实现。

## 乐观锁 ##

乐观锁与悲观锁则刚好相反，我们期望每个访问公共变量的线程都不会对变量做修改（即只是读操作），所以我们不会让这些线程互斥，但是我们还是要将修改数据的种情况考虑进来，所以**我们让线程在使用完数据以后必须要判断一下使用期间这个数据是否有被其他线程修改过**，如果有，那么程序员需要根据实际的业务场景做出一些应对措施（比如自旋）。  
实现乐观锁的关键在于线程要怎么判断使用变量的期间这个变量是否被其他线程修改过？  
据我所知的实现方式有两种：版本号机制和CAS算法。  
CAS算法（CompareAndSwap）是让线程在刚获取到变量的时候记录下变量的值（旧值），当执行完某些计算要修改这个变量的时候，我们先把旧值与变量的目前值做对比，如果旧值与这个变量目前的值不一样，那就意味着在此期间其他线程有修改过这个变量，我们就需要执行一些失败策略。  
Java的并发包下的各个Atomic类中都有一个`compareAndSet`方法，正是CAS算法的一种实现。这个方法接收两个参数分别是旧值与新值，如果旧值与它在Atomic对象中发现的值不一致，那么就不会再去将新值设置给Atomic对象。这个方法会有一个boolean类型的返回值，来告诉你操作是否成功。  
下面示例代码来自Think In Java

public class FastSimulation { 
        static final int N_ELEMENTS = 100000;
        static final int N_GENES = 30;
        static final int N_EVOLVERS = 50;
        static final AtomicInteger[][] GRID = new AtomicInteger[N_ELEMENTS][N_GENES];
        static Random rand = new Random(47);
    
        static class Evolver implements Runnable { 
            public void run() { 
                while (!Thread.interrupted()) { 
                    // 随机选择要处理的元素
                    int element = rand.nextInt(N_ELEMENTS);
                    for (int i = 0; i < N_GENES; i++) { 
                        int previous = element - 1;
                        if (previous < 0) previous = N_ELEMENTS - 1;
                        int next = element + 1;
                        if (next >= N_ELEMENTS) next = 0;
                        int oldvalue = GRID[element][i].get();
                        // 执行某种计算:
                        int newvalue = oldvalue + GRID[previous][i].get() + GRID[next][i].get();
                        newvalue /= 3; // Average the three values
                        if (!GRID[element][i].compareAndSet(oldvalue, newvalue)) { 
                            //正常的业务中，我们要在这里编写一些处理失败的政策，比如自旋。
                            // 在这里，我只是将它打印出来；
                            print("Old value changed from " + oldvalue);
                        }
                    }
                }
            }
        }
    
        public static void main(String[] args) throws Exception { 
            ExecutorService exec = Executors.newCachedThreadPool();
            for (int i = 0; i < N_ELEMENTS; i++)
                for (int j = 0; j < N_GENES; j++)
                    GRID[i][j] = new AtomicInteger(rand.nextInt(1000));
            for (int i = 0; i < N_EVOLVERS; i++)
                exec.execute(new Evolver());
            TimeUnit.SECONDS.sleep(5);
            exec.shutdownNow();
        }
    }

另外，我们通常说Random类是线程安全的，也正是因为这个类中生成随机数时用到了CAS算法。  
我们可以看一下它next方法的源码:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N6eDIwMTg_size_16_color_FFFFFF_t_70_pic_center]  
根据以上源码可以看出，在使用老种子去获取新种子的时候，如果是多线程操作，则同一时刻只会有一个线程 CAS (Conmpare And Swap，比较并交换) 成功，其他失败的线程会通过**自旋**等待获取新种子。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N6eDIwMTg_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200517235326510.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N6eDIwMTg=,size_16,color_FFFFFF,t_70#pic_center