Java多线程 a++线程问题找出减少的地方

向右看齐 2022-12-02 15:16 94阅读 0赞

### 文章目录 ###

*   *   *  AtomicInteger原子类来统计相加减少的次数
         *  synchronized 加锁进行统计
         *  CyclicBarrier 线程等待的工具类
         *  发生错误的逻辑修改

### AtomicInteger原子类来统计相加减少的次数 ###

如下的代码, 使用`AtomicInteger`原子类来统计相加减少的次数. 和发生错误的次数.

并且用布尔数组, 如果某个值, 相加了, 那么就设置成true.(boolean数组 , 里面的元素, 默认为false)

public class MultiThreadsError implements Runnable{ 
    
        static MultiThreadsError instance = new MultiThreadsError();
        int index = 0;
    
        //真正加的次数
        static AtomicInteger realIndex = new AtomicInteger();
        //发生错误的次数 AtomicInteger的作用是把i++的操作, 三步合为一步, 原理为 cas
        static AtomicInteger wrongIndex = new AtomicInteger();
    
    
        //存储当前值的数组
        final boolean[] marked = new boolean[1000000000];
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread1 = new Thread(instance);
            Thread thread2 = new Thread(instance);
            thread1.start();
            thread2.start();
    
            //主线程 等待子线程
            thread1.join();
            thread2.join();
    
            //打印结果
            System.out.println("执行结果"+instance.index);
            System.out.println("真正运行的次数"+ realIndex.get());
            System.out.println("发生错误的次数"+ wrongIndex.get());
    
        }
    
        @Override
        public void run() { 
            for (int i = 0; i < 10000; i++) { 
                index++;
    
                //自增
                realIndex.incrementAndGet();
    
                if (marked[index]) { 
                    //如果该值, 已经被加过了, 那么就会进入此代码块
                    //打印出线程错误的下标
                    System.out.println("发生了错误" + index);
                    //相加错误的数量
                    wrongIndex.incrementAndGet();
                }
                //把当前加完的值 ,设置为true
                marked[index] = true;
            }
        }
    
    }

之所以用如下的代码,进行出现错误的时候的打印, 是因为上一篇文章中, 已经提到, 在发生线程不安全问题的时候, 变量i的值, 还没来得及赋值给当前线程, 就去执行线程2的代码了. 这样就会导致i的值变少, 但是会布尔数组的索引是相同的, if的判断就是为true的.  
[https://javaweixin6.blog.csdn.net/article/details/108327742][https_javaweixin6.blog.csdn.net_article_details_108327742]  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center][]  
执行程序, 可以看到执行结果与发生错误的次数相加并不是2万,  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 1][]  
发生上面错误的原因是, 可能在执行57行代码的时候, 也会出现线程的不安全问题 . 一个线程执行完了i++操作, 执行到49行代码为false , 原本打算执行57行代码, 把标记位设置成true, 但此时发生了线程的切换. 第二个线程判断49行代码的时候的, 原本应该是true的, 但是却是false. 所以就导致了发生错误  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 2][]

### synchronized 加锁进行统计 ###

按照上面的分析, 把代码修改如下, 把可能出现线程切换的地方, 加上锁 .  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 3][]  
但此时执行代码发现, 执行的结果明明是2万 , 没有出错的 , 但是统计发生错误却是479条.  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 4][]  
假设两个线程都执行完上面的46 48行代码, 同时到50行代码去拿锁, 假设此时发生了冲突. 此时index为0 , 相加后变成了1 , 第一个线程把布尔数组的下标为1 的设置成了true, 但可能在线程2执行到51行代码的时候, 就把线程切换成了线程1, 此时线程1执行++操作, index就变成了2. 那么此时原本是想比较的是index为1 的时候, index 却变成了2.

### CyclicBarrier 线程等待的工具类 ###

这个时候, 就需要引入一个工具类, 这个工具类的作用是让线程在需要等待 的地方进行等待. 不想让线程等待的地方, 可以进行统一的执行.

这个工具类就是CyclicBarrier, 可以根据我们的需要, 在某个地方进行等待, 直到等待的资源都就绪了,再执行代码 .

引入CyclicBarrier 工具类后, 改造如下 . 在循环一开始和执行++操作的时候, 进行等待,

package com.thread.background;
    
    import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CyclicBarrier;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /** * 类名称:MultiThreadsError * 类描述: 第一种：运行结果出错。 演示计数不准确（减少），找出具体出错的位置。 * * @author: https://javaweixin6.blog.csdn.net/ * 创建时间:2020/8/31 19:18 * Version 1.0 */
    public class MultiThreadsError implements Runnable{ 
    
        static MultiThreadsError instance = new MultiThreadsError();
        int index = 0;
    
        //真正加的次数
        static AtomicInteger realIndex = new AtomicInteger();
        //发生错误的次数 AtomicInteger的作用是把i++的操作, 三步合为一步, 原理为 cas
        static AtomicInteger wrongIndex = new AtomicInteger();
    
        //CyclicBarrier构造方法, 传递的参数代表需要等待几个线程
        static volatile CyclicBarrier cyclicBarrier1 = new CyclicBarrier(2);
        static volatile CyclicBarrier cyclicBarrier2 = new CyclicBarrier(2);
    
        //存储当前值的数组
        final boolean[] marked = new boolean[1000000000];
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread1 = new Thread(instance);
            Thread thread2 = new Thread(instance);
            thread1.start();
            thread2.start();
    
            //主线程 等待子线程
            thread1.join();
            thread2.join();
    
            //打印结果
            System.out.println("执行结果"+instance.index);
            System.out.println("真正运行的次数"+ realIndex.get());
            System.out.println("发生错误的次数"+ wrongIndex.get());
    
        }
    
        @Override
        public void run() { 
            for (int i = 0; i < 10000; i++) { 
    
                try { 
                    //等待的重置
                    cyclicBarrier2.reset();
                    //等待的两个线程如果都到齐了, 那么就放行.
                    cyclicBarrier1.await();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } catch (BrokenBarrierException e) { 
                    e.printStackTrace();
                }
    
                index++;
    
                //两个线程都去执行++操作的时候, 才去放行
                try { 
                    //等待的重置
                    cyclicBarrier1.reset();
                    cyclicBarrier2.await();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } catch (BrokenBarrierException e) { 
                    e.printStackTrace();
                }
    
                //自增
                realIndex.incrementAndGet();
    
                synchronized (instance) { 
                    if (marked[index]) { 
                        //如果该值, 已经被加过了, 那么就会进入此代码块
                        //打印出线程错误的下标
                        System.out.println("发生了错误" + index);
                        //相加错误的数量
                        wrongIndex.incrementAndGet();
                    }
                    //把当前加完的值 ,设置为true
                    marked[index] = true;
                }
    
            }
        }
    
    }

可以看到统计的 发生错误的统计还是出错了. 但是可以发现的规律是统计的发生的错误, 都是偶数.  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 5][]  
主要是因为synchronized的可见性, 让两个线程的结果可以互相的通知.

### 发生错误的逻辑修改 ###

需要把上面的代码, 修改一处. 不仅仅是判断当前索引, 还得判断上一个索引是否为true.  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 6][]  
通过debug断点可以看到. 布尔数组的规律基本上是前面一个是true, 后面一个是false.  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 7][]  
把布尔数组的第一个元素设置成true, 用于防止第一次就发生了错误  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 8][]  
此时控制台打印如下 , 可以看到统计没有出错了.  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 9][]

完整的代码如下:

package com.thread.background;
    
    import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CyclicBarrier;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /** * 类名称:MultiThreadsError * 类描述: 第一种：运行结果出错。 演示计数不准确（减少），找出具体出错的位置。 * * @author: https://javaweixin6.blog.csdn.net/ * 创建时间:2020/8/31 19:18 * Version 1.0 */
    public class MultiThreadsError implements Runnable{ 
    
        static MultiThreadsError instance = new MultiThreadsError();
        int index = 0;
    
        //真正加的次数
        static AtomicInteger realIndex = new AtomicInteger();
        //发生错误的次数 AtomicInteger的作用是把i++的操作, 三步合为一步, 原理为 cas
        static AtomicInteger wrongIndex = new AtomicInteger();
    
        //CyclicBarrier构造方法, 传递的参数代表需要等待几个线程
        static volatile CyclicBarrier cyclicBarrier1 = new CyclicBarrier(2);
        static volatile CyclicBarrier cyclicBarrier2 = new CyclicBarrier(2);
    
        //存储当前值的数组
        final boolean[] marked = new boolean[1000000000];
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread1 = new Thread(instance);
            Thread thread2 = new Thread(instance);
            thread1.start();
            thread2.start();
    
            //主线程 等待子线程
            thread1.join();
            thread2.join();
    
            //打印结果
            System.out.println("执行结果"+instance.index);
            System.out.println("真正运行的次数"+ realIndex.get());
            System.out.println("发生错误的次数"+ wrongIndex.get());
    
        }
    
        @Override
        public void run() { 
            //把布尔数组的第一个元素设置成true, 用于防止第一次就发生了错误
            marked[0] = true;
    
            for (int i = 0; i < 10000; i++) { 
    
                try { 
                    //等待的重置
                    cyclicBarrier2.reset();
                    //等待的两个线程如果都到齐了, 那么就放行.
                    cyclicBarrier1.await();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } catch (BrokenBarrierException e) { 
                    e.printStackTrace();
                }
    
                index++;
    
                //两个线程都去执行++操作的时候, 才去放行
                try { 
                    //等待的重置
                    cyclicBarrier1.reset();
                    cyclicBarrier2.await();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } catch (BrokenBarrierException e) { 
                    e.printStackTrace();
                }
    
                //自增
                realIndex.incrementAndGet();
    
                synchronized (instance) { 
                    if (marked[index]  &&  marked[index-1]) { 
                        //如果该值, 已经被加过了, 那么就会进入此代码块
                        //打印出线程错误的下标
                        System.out.println("发生了错误" + index);
                        //相加错误的数量
                        wrongIndex.incrementAndGet();
                    }
                    //把当前加完的值 ,设置为true
                    marked[index] = true;
                }
            }
        }
    
    }

[https_javaweixin6.blog.csdn.net_article_details_108327742]: https://javaweixin6.blog.csdn.net/article/details/108327742
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/b9e66e5c253a4d4185c2cc89afae6c4b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/fcffd13e5c744097848b147c918bd0a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/c25b953a2cb841a7bffcb4d45143481e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/17e0efb154034564938346ebd5f52fe9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/80665fedd80f469a8e5f1ba2606ba7f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/18a08fe98a874c549e4965ba89d5827b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/b1319f2b8b7244a591b89aa01ecccc94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/31b9708cabdf4ab088dc6557100ae9f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/1ba65c0f475f4c7ab8d7f7732f569727.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjI5NjY5_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221123/60fc875bc39f40ef82394e922a7ea30d.png