为什么不要在多线程中使用count++

谁借莪１个温暖的怀抱￠ 2023-07-12 05:19 1阅读 0赞

在单线程下，我们经常使用count++将count的值自增1，也不会发生什么错误，但是在多线程下，可能使用count++结果可能就往往出乎我们的意料了.

我们以count++，一直从1加到5为例

### 方式一(多个线程操作各自的变量): ###

public class ThreadCount extends Thread { 
        private Integer count = 0;  
        public ThreadCount(String name) { 
            this.setName(name);
        }
        
        @Override
        public void run() { 
            while (count <5) { 
                System.out.println(Thread.currentThread().getName()+":"+count+"--->"+(++count));
            }
        }
        
        public static void main(String[] args) { 
            ThreadCount a = new ThreadCount("A");
            ThreadCount b = new ThreadCount("B");
            ThreadCount c = new ThreadCount("C");
            ThreadCount d = new ThreadCount("D");
            ThreadCount e = new ThreadCount("E");
            a.start();
            b.start();
            c.start();
            d.start();
            e.start();
        }
    }

运行结果(多次运行结果不一致,但最终结果都是每个线程的count值变为5):  
![在这里插入图片描述][20190606175126491.png]  
内存模型:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25pYW5nb3UwOTE1_size_16_color_FFFFFF_t_70]  
方式一:  
我们创建了3个线程，每个线程都有各自的count变量，自己减少自己的count变量的值.这样的情况就是变量不共享，并不存在多个线程访问同一个实例变量的情况.

### 方式二(多个线程操纵共享变量): ###

public class ThreadCount1 extends Thread { 
        private Integer count = 0;
        @Override
        public void run() { 
            System.out.println(Thread.currentThread().getName()+":"+count+"--->"+(++count));
        }
        public static void main(String[] args) { 
            ThreadCount1 threadCount1 = new ThreadCount1();
            Thread threadA = new Thread(threadCount1, "A");
            Thread threadB = new Thread(threadCount1, "B");
            Thread threadC = new Thread(threadCount1, "C");
            Thread threadD = new Thread(threadCount1, "D");
            Thread threadE = new Thread(threadCount1, "E");
            threadA.start();
            threadB.start();
            threadC.start();
            threadD.start();
            threadE.start();
        }
    }

运行结果(多次运行结果不一致,count值可能为5可能不为5):  
![在这里插入图片描述][20190606182050472.png]  
内存模型:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25pYW5nb3UwOTE1_size_16_color_FFFFFF_t_70 1]  
方式二:  
我们还是新建了5个线程，但是他们是共享主内存中的count变量.我们改变共享变量中的值分为3步:  
     ①.从主内存中取出  
从运行结果就可以看出,线程B和A同时对count进行了处理，产生了线程安全的问题,使的最终结果变为了4.

注意:虽然`System.out.println()`是同步的，但是count++操作确实在进入println()之前发生的

public void println(String x) { 
            synchronized (this) { 
                print(x);
                newLine();
            }
        }

### 方式三(使用锁将count++进行同步): ###

①使用`synchronized`进行同步，既能保证一致性又能保证原子性

@Override
        public synchronized void  run() { 
            System.out.println(Thread.currentThread().getName() + ":" + count + "--->" + (++count));
        }

②…其它锁,`ReentrantLock`等

运行结果(每次运行结果相同,count变为5):  
![在这里插入图片描述][20190606184027118.png]  
方式三:使用锁进行同步,使的同一时间只有一个线程能够进行访问.(原理以后细讲)

### ???这里要注意只是用volatile(轻量级锁)只能保证可见性而不能保证count++操作的原子性 ###

private volatile Integer count = 0;

运行结果(每次运行结果不同,count的值不一定为5)  
![在这里插入图片描述][2019060619524597.png]  
可见性:即对于一个volatile的读总能看到(任意线程)对这个volatile变量最后的写入.(原理:内存屏蔽)  
原子性:对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性

count++并不是一个原子操作,它分为3步:  
     ①.从内存中取出原有的count值  
     ②.进行i++的操作  
     ③.把count++后的值赋给count并写入到主内存

### 方式四(使用Atomic相关类): ###

private static AtomicInteger count = new AtomicInteger(0);
        @Override
        public void   run() { 
            System.out.println(Thread.currentThread().getName() + ":" + count + "--->" + (count.incrementAndGet()));
        }

运行结果(每次运行结果不相同,count变为5):  
![在这里插入图片描述][20190606202900408.png]  
方式四:使用`AtomicInteger`类并调用`incrementAndGet`进行count++的操作.(原理:CAS)

### 方式五(使用`java.util.concurrent(juc)`下的一些类,如`CountDownLatch`或者`CyclicBarrier`等) ###

因为我对juc下的一些类不太了解，以后深入理解了在来继续写

[20190606175126491.png]: https://img-blog.csdnimg.cn/20190606175126491.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25pYW5nb3UwOTE1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190606181152911.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25pYW5nb3UwOTE1,size_16,color_FFFFFF,t_70
[20190606182050472.png]: https://img-blog.csdnimg.cn/20190606182050472.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25pYW5nb3UwOTE1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190606182702250.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25pYW5nb3UwOTE1,size_16,color_FFFFFF,t_70
[20190606184027118.png]: https://img-blog.csdnimg.cn/20190606184027118.png
[2019060619524597.png]: https://img-blog.csdnimg.cn/2019060619524597.png
[20190606202900408.png]: https://img-blog.csdnimg.cn/20190606202900408.png