多线程入门实例（一）

矫情吗；* 2022-10-31 00:45 130阅读 0赞

# 多线程入门示例： #

## 1： 验证两个线程在同时操作同一个变量，一增一减，最终结果是否为初始值？ ##

package com.weidd.best.multiThread;
    
    import org.junit.Test;
    
    /**
     * @program: SortDemo
     * @author: weidd
     * @date: 2021-02-20 10:29
     **/
    public class ThreadTest1 {
    
        //定义一个成员变量初始值为0 
        private int number = 0;
    
        private void read() {
            System.out.println("number = " + number);
        }
      
        private void write(int change) {
            number += change;
        }
    
        // 在write方法执行时,实际执行三个语句,(load,add,store 即不是一个原子操作.)
    
        //两个线程,一个线程做加法,一个线程做减法,测试最终结果是否为0
        @Test
        public void test1() throws InterruptedException {
            //开启线程加10000次
            new Thread(() -> {
                for (int i = 0; i < 10000; i++) {
                    write(1);
                }
                System.out.println("加1操作完成");
            }).start();
    
            //开启线程减10000次
            new Thread(() -> {
                for (int i = 0; i < 10000; i++) {
                    write(-1);
                }
                System.out.println("减1操作完成");
            }).start();
    
            //睡眠1秒保证线程执行完成
            Thread.sleep(1000);
            read();
        }
    
    }

运行结果：并非是最初猜想。

> 加1操作完成  
> 减1操作完成  
> number = -587
> 
> 加1操作完成  
> 减1操作完成  
> number = -8

## 2：number ≠ 0 的问题分析。 ##

从多线程的角度，上面做法错误明显，当多个线程同时进行读写操作时，要保证结果正确，必须保证每一步操作都是**原子操作**。（原子操作是不能被中断的一个或一系列操作。）

在上述write（）方法执行中，其实是执行了三个操作。【程序从主内存中拷贝一个number副本到本地线程，修改number后将修改后数据放回到主内存。】

>  load --拷贝number到本地线程中
> 
> add --做加减操作
> 
> store --写回主内存

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTU1OTI4Mg_size_16_color_FFFFFF_t_70][]

最终结果不是预想的number = 0的原因：

> 第一个线程拷贝主内存中number 到自己的线程，假设number = 0 ，此时第一个线程被操作系统暂停。
> 
> 系统开始操作第二个线程，此时第二个线程从主内存中拿到的number = 0；
> 
> 第二个线程将number -1 = -1 ，然后写入到主内存中，此时主内存中number = -1 ；
> 
> 第一个线程继续被调度执行，仍然对其持有的副本进行操作，对其 +1 ，然后写入到主内存，此时主内存中为 1；
> 
> 上面操作为一增一减，但是结果已经不是最初设想的，一增一减结果为0 。如此经过数次操作后，最终number自然也就不为0了。

## 3：引入synchronized 的使用 ##

线程在执行write()时，首先检查是否有线程正在执行，如有则等待。

package com.weidd.best.multiThread;
    
    import org.junit.Test;
    
    public class ThreadTest1 {
    
        //定义一个成员变量初始值为0
        private int number = 0;
    
        private void read() {
            System.out.println("number = " + number);
        }
    
        // 定义一把锁,当某一线程获取到此对象,其他线程只能处于等待状态直至锁释放
        private final Object lock = new Object();
    
        // 对方法进行加锁
        private void write(int change) {
            synchronized (lock) {
                number += change;
            }
        }
    
    
        //两个线程,一个线程做加法,一个线程做减法,测试最终结果为0
        @Test
        public void test1() throws InterruptedException {
            //开启线程加10000次
            new Thread(() -> {
                for (int i = 0; i < 10000; i++) {
                    write(1);
                }
                System.out.println("加1操作完成");
            }).start();
    
            //开启线程减10000次
            new Thread(() -> {
                for (int i = 0; i < 10000; i++) {
                    write(-1);
                }
                System.out.println("减1操作完成");
            }).start();
    
            //睡眠1秒保证线程执行完成
            Thread.sleep(1000);
            read();
        }
    
    }

通过如上方式可以解决在多线程中写的问题。但是问题来了，读是否有问题呢？

如果读时不加锁，那么在读取时，将number读取到自己的本地内存中，这就可能会出现读取的不是主内存中最新的数据。

package com.weidd.best.multiThread;
    
    import org.junit.Test;
    
    
    public class ThreadTest1 {
    
        //定义一个成员变量初始值为0
        private int number = 0;
    
        private void read() {
            System.out.println("number = " + number);
        }
    
        // 定义一把锁,当某一线程获取到此对象,其他线程只能处于等待状态直至锁释放
        private final Object lock = new Object();
    
        // 对方法进行加锁
        private void write(int change) {
            synchronized (lock) {
                number += change;
            }
        }
    
        // 在write方法执行时,实际执行三个语句,(load,add,store 即不是一个原子操作.)
        @Test//两个线程一个线程做加法一个线程读取.测试当读不加锁时，读到的数据是否为主内存中最新的数据
        public void test2() throws InterruptedException {
            //开启线程加10000次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    write(1);
                    System.out.println("写入 " + number);
                }
                System.out.println("加1操作完成");
            }).start();
    
            //开启线程减10000次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    read();
                }
                System.out.println("读取结束");
            }).start();
            Thread.sleep(1000);
        }
    
        
    }

执行后结果：

> 。。。。略。。。。
> 
> 写入 15  
> 写入 16  
> 写入 17  
> number = 15  
> number = 18  
> number = 18  
> 写入 18  
> 写入 19  
> 写入 20  
> 写入 21  
> 写入 22  
> number = 18
> 
> 。。。。略。。。。

由执行结果可知，线程在做读操作时候，确实读到的非主存中最新的数据。

## 4：考虑给读线程也加上锁。 ##

//给读方法加上同步锁
     private void read(){
           synchronized (lock) {
                System.out.println("number = " + number);
                }
            }

如此操作又会出现什么样的问题呢？

> 写入 1  
> 写入 2  
> 写入 3  
> 。。。  
> 写入 39  
> 写入 40  
> number = 41  
> 。。。  
> number = 41  
> 写入 41  
> number = 41  
> number = 42  
> 写入 42  
> number = 42  
> 。。。  
> number = 42  
> number = 42  
> 写入 43  
> number = 43  
> 。。。  
> number = 43  
> 读取结束
> 
>   
> 写入 44  
> 写入 45  
> 写入 46  
> 。。。  
> 写入 98  
> 写入 99  
> 写入 100  
> 加1操作完成

从执行结果来看是读写都没问题了，读线程每次都能读到主存中最新的数据。但是大部分时候需求是写完全执行完成后，读到最终的值。

## 5: 给读加判断，当写完成后再去读。首次尝试： ##

public class ThreadTest1 {
    
        //定义一个成员变量初始值为0
        private int number = 0;
        // 定义一把锁,当某一线程获取到此对象,其他线程只能处于等待状态直至锁释放
        private final Object lock = new Object();
    
        boolean complete = false;
    
        private void read() {
            synchronized (lock) {
                while (!complete) {
                    System.out.println("还未完成写...");
                }
                System.out.println("number = " + number);
            }
        }
    
        // 对方法进行加锁
        private void write(int change) {
            synchronized (lock) {
                number += change;
            }
        }
    
        @Test//首次尝试当number未到完成写，读线程等待。
        public void test3() throws InterruptedException {
            //开启线程加10000次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    write(1);
                    System.out.println("写入 " + number);
                }
                System.out.println("加1操作完成");
                complete = true;
            }).start();
    
            //开启线程减10000次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    read();
                }
                System.out.println("读取结束");
            }).start();
            Thread.sleep(1000);
        }
    
    
    }

如上代码需要更正：由于对Junit的错误使用，达不到线程死锁，卡在读线程的效果，如需达到效果需要将@test方法改成main方法中运行。（原因：Junit是不支持多线程的，其执行会在主线程运行结束后关闭，main方法不会出现这样。因此在多线程中做测试时需注意避开Junit单元测试。）

package com.weidd.best.multiThread;
    
    import org.junit.Test;
    
    public class ThreadTest2 {
    
        //定义一个成员变量初始值为0
        private static int number = 0;
        // 定义一把锁,当某一线程获取到此对象,其他线程只能处于等待状态直至锁释放
        private static final Object lock = new Object();
    
        static boolean complete = false;
    
        private static void read() {
            synchronized (lock) {
                while (!complete) {
                    System.out.println("还未完成写...");
                }
                System.out.println("number = " + number);
            }
        }
    
        // 对方法进行加锁
        private static void write(int change) {
            synchronized (lock) {
                number += change;
            }
        }
    
        //首次尝试当number未到完成写，读线程等待。
        public static void  main(String[] args) throws InterruptedException {
            System.out.println("");
            //开启线程加10000次
            new Thread(() -> {
                for (int i = 0; i < 10000; i++) {
                    write(1);
                    System.out.println("写入 " + number);
                }
                System.out.println("加1操作完成");
                complete = true;
            }).start();
    
            //开启线程减100次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    read();
                }
                System.out.println("读取结束");
            }).start();
            Thread.sleep(1000);
        }
    }

执行结果：

> 写入 1  
> 写入 2  
> 写入 3  
> 。。。  
> 。。。  
> 写入 33  
> 写入 34  
> 写入 35  
> 写入 36  
> 还未完成写...  
> 还未完成写...  
> 还未完成写...  
> 还未完成写...  
> 还未完成写...  
> 还未完成写...  
> 还未完成写...  
> 还未完成写...  
> 还未完成写...
> 
> ...
> 
> 还未完成写...

从执行结果来看：程序一直卡在了等待写完成。。

分析：当进入到读线程，此时读获取了锁，write方法就必须等待read线程释放锁资源，write等待获取锁，但是read又不释放锁，此时就陷入了死局。

(死锁出现的条件：read线程占用着cpu资源，导致write线程持续处于等待状态。)

> ### 死锁产生的4个必要条件？ ###
> 
> 1.  互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
> 2.  请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
> 3.  不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
> 4.  环路等待条件：在发生死锁时，必然存在一个进程--资源的环形链。

## 6：解决5中给读加锁的方式导致了线程处于死锁。 ##

解决5中的办法可以是在读的时候发现写未完成，此时处于等待状态，但是不去阻塞线程，等写完成后通知读来读取number。Java中提供有等待与唤醒的方法(等待方法： wait()，唤醒方法：notify())。一般在多线程情况下在做唤醒操作时，优先选择全部唤醒：notifyAll()。

注意： wait()和notify()方法均必须在synchronized中执行.

package com.weidd.best.multiThread;
    
    import org.junit.Test;
    
    public class ThreadTest1 {
        //定义一个成员变量初始值为0
        private int number = 0;
        // 定义一把锁,当某一线程获取到此对象,其他线程只能处于等待状态直至锁释放
        private final Object lock = new Object();
    
        boolean complete = false;
    
        private void read() {
            synchronized (lock) {
                while (!complete) {
                    System.out.println("还未完成写...");
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("number = " + number);
            }
        }
    
        // 对方法进行加锁
        private void write(int change) {
            synchronized (lock) {
                number += change;
            }
        }
    
        // 在write方法执行时,实际执行三个语句,(load,add,store 即不是一个原子操作.)
    
        /*两个线程一个线程做加法一个线程读取.测试使用wait()和notify()方法实现,
          当写线程未完成时,使用wait()方法使当前线程处于等待状态,但是不阻塞,不占用CPU资源,
          当写线程完成后,使用notify()方法来唤醒处于等待状态的线程.
          注意: wait()和notify()方法均必须在synchronized中执行.*/
        @Test
        public void test3() throws InterruptedException {
            //开启线程加100次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    write(1);
                    System.out.println("写入 " + number);
                }
                System.out.println("加1操作完成");
                complete = true;
                // 写入完成，唤醒读取线程，wait/notify 操作必须在 synchronized 中执行。 否则不能成功唤醒线程.
                synchronized (lock) {
                    lock.notify();
                }
            }).start();
    
            //开启线程读100次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    read();
                }
                System.out.println("读取结束");
            }).start();
            Thread.sleep(1000);
        }
    
    }

运行结果：

> 写入 1  
> 写入 2  
> 写入 3  
> 写入 4  
> 写入 5  
> 还未完成写...(此时读线程处于等待状态，但是不阻塞)  
> 写入 6  
> 写入 7  
> 。。。  
> 写入 99  
> 写入 100  
> 加1操作完成  
> number = 100  
> number = 100  
> 。。。  
> number = 100  
> 读取结束

## 7：对synchronized加锁的优化，引入ReentrantLock。 ##

由于5中在使用synchronized时导致死锁的出现，现需寻找更优的办法来既达到加锁的目的同时又不出现死锁。synchronized本身又是一个很重的操作。

现引入ReentrantLock来替换synchronized。

//使用ReentrantLock替换synchronized
        ReentrantLock reent = new ReentrantLock();
    
        private void write(int change) {
            reent.lock();
            number += change;
            reent.unlock();
        }

从形式上看，仅是换一个加锁的方式，实际上可以给线程设置一个尝试获取锁的等待时间，超过了等待时间将不再尝试获取锁。

package com.weidd.best.multiThread;
    
    import org.junit.Test;
    
    import javax.sound.midi.Soundbank;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * @program: SortDemo
     * @author: weidd
     * @date: 2021-02-23 09:10
     **/
    public class ThreadTest2 {
    
        //定义一个成员变量初始值为0
        private static int number = 0;
        // 定义一把锁,当某一线程获取到此对象,其他线程只能处于等待状态直至锁释放
    //    private static final Object lock = new Object();
        //使用ReentrantLock替换synchronized
        static ReentrantLock reent = new ReentrantLock();
    
        static boolean complete = false;
    
        private static void read() throws InterruptedException {
            reent.lock();
            while (!complete) {
                System.out.println("还未写完 ");
                Thread.sleep(500);
            }
            System.out.println("number**** = " + number);
            reent.unlock();
        }
    
        private static void write(int change) throws InterruptedException {
            if (reent.tryLock(1, TimeUnit.SECONDS)) {
                number += change;
                reent.unlock();
            } else {
                //1秒后再次尝试获取锁,如果还是获取不到,就不再等待
                System.out.println("1秒了还是没有获的锁,不等了...");
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            //开启线程加1000次
            new Thread(() -> {
                for (int i = 0; i < 1000; i++) {
                    try {
                        write(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("写入 " + number);
                }
                complete = true;
                System.out.println("加1操作完成");
            }).start();
    
            //开启线程读100次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    try {
                        read();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("读取结束");
            }).start();
        }
    }

执行结果：

> 还未写完   
> 还未写完   
> 1秒了还是没有获的锁,不等了...  
> 。。。  
> 写入 0  
> 还未写完   
> 还未写完   
> 1秒了还是没有获的锁,不等了...  
> 写入 0  
> 还未写完   
> 还未写完   
> 1秒了还是没有获的锁,不等了...  
> 。。。
> 
>

优势1：ReentrantLock比synchronized更安全可以避免无限的等待。

同时还有实现替换wait和notify的方法

## 8：ReentrantLock中引入Condition类实现wait/notify的方法。 ##

synchronized中有等待wait和唤醒notify方法，ReentrantLock中引入Condition类来实现wait/notify。与之对应的await/singnal。

package com.weidd.best.multiThread;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * @program: SortDemo
     * @author: weidd
     * @date: 2021-02-23 09:10
     **/
    public class ThreadTest3 {
    
        //定义一个成员变量初始值为0
        private static int number = 0;
        // 定义一把锁,当某一线程获取到此对象,其他线程只能处于等待状态直至锁释放
    //    private static final Object lock = new Object();
        //使用ReentrantLock替换synchronized
        static ReentrantLock recent = new ReentrantLock();
        // 使用Condition中的await和 signal替换synchronized中的wait/notify
        static Condition condition = recent.newCondition();
    
        static boolean complete = false;
    
        private static void read() throws InterruptedException {
            recent.lock();
            while (!complete) {
                System.out.println("还未写完 ");
                condition.await();
            }
            System.out.println("number**** = " + number);
            recent.unlock();
        }
    
        private static void write(int change) throws InterruptedException {
            if (recent.tryLock(1, TimeUnit.SECONDS)) {
                number += change;
                recent.unlock();
            } else {
                //1秒后再次尝试获取锁,如果还是获取不到,就不再等待
                System.out.println("1秒了还是没有获的锁,不等了...");
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            //开启线程加1000次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    try {
                        write(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("写入 " + number);
                }
    
                complete = true;
                recent.lock();
                condition.signal();
                recent.unlock();
                System.out.println("加1操作完成");
            }).start();
    
            //开启线程读100次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    try {
                        read();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("读取结束");
            }).start();
        }
    }

执行结果： await和signal（signalAll）完美替换wait/notify。

> 还未写完   
> 写入 1  
> 写入 2  
> 。。。  
> 写入 97  
> 写入 98  
> 写入 99  
> 写入 100  
> 加1操作完成  
> number\*\*\*\* = 100  
> number\*\*\*\* = 100  
> number\*\*\*\* = 100  
> 。。。  
> number\*\*\*\* = 100  
> 读取结束

Condition功能：

1：自动唤醒，多久后未被唤醒自动醒。

if (condition.await(1, TimeUnit.SECOND)) {
        // 1 秒内被 signal 唤醒
    } else {
        // 1 秒内没有被唤醒，自己醒
    }

2：不同的情境下，通过使用多个不同的 Condition，再调用不同 Condition 的 signal 方法，就可以唤醒自己想要唤醒的某个或某一部分线程。

## 9：ReentrantLock进一步理解（有疑问） ##

问题点：当每次读都要加锁的话会导致性能降低，但是如果不给读加锁每次读有拿不到最新的值。

是否有写时候其他线程阻塞，没有写的时候线程不阻塞？？ 读写锁的引入

public class ThreadTest4 {
    
        //定义一个成员变量初始值为0
        private static int number = 0;
        // 定义一把锁,当某一线程获取到此对象,其他线程只能处于等待状态直至锁释放
    //    private static final Object lock = new Object();
        //使用ReentrantLock替换synchronized
    //    static ReentrantLock recent = new ReentrantLock();
        //增加读写锁,使写的时候别的线程阻塞,读的时候线程不阻塞.
        private final static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        private final static Lock readLock = readWriteLock.readLock();//读锁
        private final static Lock writeLock = readWriteLock.writeLock();
        private final static Condition condition = writeLock.newCondition();
        // 使用Condition中的await和 signal替换synchronized中的wait/notify
    //    static Condition condition = recent.newCondition();
    
        static boolean complete = false;
    
        private static void read() {
            readLock.lock();
            while (!complete) {
                System.out.println("还未写完 ");
    //            readLock.wait();// TODO 此处存疑
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("等着吧,但不阻塞 ");
            }
            System.out.println("number **** = " + number);
            readLock.unlock();
        }
    
        private static void write(int change) {
            writeLock.lock();
            number += change;
            writeLock.unlock();
    
        }
    
        public static void main(String[] args) throws InterruptedException {
            //开启线程加1000次
            new Thread(() -> {
                complete=false;
                for (int i = 0; i < 100; i++) {
                    write(1);
                    System.out.println("写入 " + number);
                }
                complete = true;
    
                writeLock.lock();
                condition.signal();
                writeLock.unlock();
                System.out.println("加1操作完成");
            }).start();
    
            //开启线程读100次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    read();
                }
                System.out.println("读取结束");
            }).start();
    
            Thread.sleep(1000);
        }
    
    }

读写锁出现，但是在读的时候不允许写，在一定程度上还是对性能上有影响的，此为悲观锁的体现，下一步可以持续对其优化，引入乐观锁。

## 10：ReentrantLock进一步优化： ##

乐观锁的引入：读取数据后做一个检查，判断在读的过程中是否有写的发生。如果没有，说明乐观锁获取到的数据是正确的，效率提高；如果检查发现读的时候有写入，此时再使用悲观锁读出正确的数。

版本号是乐观锁的常用方式。

package com.weidd.best.multiThread;
    
    import java.util.concurrent.locks.StampedLock;
    
    public class ThreadTest5 {
    
        //定义一个成员变量初始值为0
        private static int number = 0;
        // 定义一把锁,当某一线程获取到此对象,其他线程只能处于等待状态直至锁释放
    //    private static final Object lock = new Object();
        //使用ReentrantLock替换synchronized
    //    static ReentrantLock recent = new ReentrantLock();
        //增加读写锁,使写的时候别的线程阻塞,读的时候线程不阻塞.
    //    private final static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    //    private final static Lock readLock = readWriteLock.readLock();//读锁
    //    private final static Lock writeLock = readWriteLock.writeLock();
    //    private final static Condition condition = writeLock.newCondition();
        static StampedLock stampedLock = new StampedLock();
        // 使用Condition中的await和 signal替换synchronized中的wait/notify
    //    static Condition condition = recent.newCondition();
    
        static boolean complete = false;
    
        private static void read() {
            // 尝试乐观读取
            long stamp = stampedLock.tryOptimisticRead();
            int readNumber = number;
            System.out.println("乐观读取到:readNumber **** = " + readNumber);
    
            // 检查乐观锁读取的值是是否有误
            if (!stampedLock.validate(stamp)) {
                stamp = stampedLock.readLock();
                System.out.println("乐观锁读取的值" + readNumber + "有误改用悲观锁" + number);
                stampedLock.unlockRead(stamp);
            }
        }
    
        private static void write(int change) {
            long stamp = stampedLock.writeLock();
            number += change;
            stampedLock.unlockWrite(stamp);
        }
    
        public static void main(String[] args) throws InterruptedException {
            //开启线程加1000次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    write(1);
                    System.out.println("写入 " + number);
                }
                System.out.println("加1操作完成");
            }).start();
    
            //开启线程读100次
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    read();
                }
                System.out.println("读取结束");
            }).start();
    
            Thread.sleep(1000);
        }
    
    }

执行结果：引入乐观锁，既能保证程序的执行效率同时又能保证数值的正确性。（此过程涉及到锁的升级。）

>   
> 写入 1  
> 。。。  
> 写入 11  
> 乐观读取到:readNumber \*\*\*\* = 5  
> 写入 12  
> 乐观锁读取的值5有误改用悲观锁12  
> 乐观读取到:readNumber \*\*\*\* = 12  
> 。。。  
> 乐观读取到:readNumber \*\*\*\* = 12  
> 写入 13  
> 乐观锁读取的值12有误改用悲观锁13  
> 乐观读取到:readNumber \*\*\*\* = 13  
> 写入 14  
> 乐观锁读取的值13有误改用悲观锁14  
> 写入 15  
> 乐观读取到:readNumber \*\*\*\* = 15  
> 写入 16  
> 乐观锁读取的值15有误改用悲观锁16  
> 写入 17  
> 。。。  
> 写入 26  
> 乐观读取到:readNumber \*\*\*\* = 17  
> 写入 27  
> 乐观锁读取的值17有误改用悲观锁27  
> 乐观读取到:readNumber \*\*\*\* = 27  
> 写入 28  
> 乐观锁读取的值27有误改用悲观锁28  
> 乐观读取到:readNumber \*\*\*\* = 28  
> 乐观锁读取的值28有误改用悲观锁29  
> 乐观读取到:readNumber \*\*\*\* = 29  
> 。。。  
> 乐观读取到:readNumber \*\*\*\* = 29  
> 写入 29  
> 写入 30  
> 写入 31  
> 乐观读取到:readNumber \*\*\*\* = 29  
> 写入 32  
> 乐观锁读取的值29有误改用悲观锁32  
> 乐观读取到:readNumber \*\*\*\* = 33  
> 乐观锁读取的值33有误改用悲观锁33  
> 乐观读取到:readNumber \*\*\*\* = 33  
> 。。。  
> 乐观读取到:readNumber \*\*\*\* = 33  
> 写入 33  
> 写入 34  
> 写入 35  
> 写入 36  
> 写入 37  
> 写入 38  
> 乐观读取到:readNumber \*\*\*\* = 33  
> 写入 39  
> 乐观锁读取的值33有误改用悲观锁39  
> 写入 40  
> 。。。  
> 写入 45  
> 乐观读取到:readNumber \*\*\*\* = 40  
> 写入 46  
> 乐观锁读取的值40有误改用悲观锁46  
> 写入 47  
> 。。。  
> 写入 60  
> 写入 61  
> 乐观读取到:readNumber \*\*\*\* = 47  
> 乐观锁读取的值47有误改用悲观锁62  
> 乐观读取到:readNumber \*\*\*\* = 62  
> 。。。  
> 乐观读取到:readNumber \*\*\*\* = 62  
> 写入 62  
> 。。。  
> 写入 73  
> 乐观读取到:readNumber \*\*\*\* = 62  
> 乐观锁读取的值62有误改用悲观锁74  
> 乐观读取到:readNumber \*\*\*\* = 74  
> 。。。  
> 乐观读取到:readNumber \*\*\*\* = 74  
> 写入 74  
> 。。。  
> 写入 81  
> 乐观读取到:readNumber \*\*\*\* = 74  
> 写入 82  
> 乐观锁读取的值74有误改用悲观锁82  
> 写入 83  
> 写入 84  
> 写入 85  
> 。。。  
> 写入 95  
> 写入 96  
> 写入 97  
> 写入 98  
> 乐观读取到:readNumber \*\*\*\* = 83  
> 写入 99  
> 乐观锁读取的值83有误改用悲观锁99  
> 乐观读取到:readNumber \*\*\*\* = 99  
> 写入 100  
> 乐观锁读取的值99有误改用悲观锁100  
> 加1操作完成  
> 乐观读取到:readNumber \*\*\*\* = 100  
> 。。。  
> 乐观读取到:readNumber \*\*\*\* = 100  
> 读取结束

## 结论： ##

现实当中对乐观锁和悲观锁的选取，取决于具体的业务。如读频繁，写操作较少，优先选择乐观锁；但是如果写操作较多，还是优选悲观锁。

未完待续~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTU1OTI4Mg_size_16_color_FFFFFF_t_70]: /images/20221024/ee47c623cd744b6d8316026153da61a9.png