Runnable实现类的成员变量之线程安全问题

最新推荐文章于 2024-09-02 20:59:26 发布

原创最新推荐文章于 2024-09-02 20:59:26 发布 · 1.6k 阅读

0 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

48 篇文章

订阅专栏

本文通过实例演示了在多线程环境下，Runnable实现类的成员变量如何成为线程不安全的因素，并提供了两种解决方法：使用AtomicInteger类和synchronized关键字，确保数据在并发操作下的正确性和一致性。

文章目录

一. 先上结论

当多个线程共用一个Runnable实现类的对象numRunnable时（Thread thread = new Thread(numRunnable,"thread"+i)），Runnable实现类的成员变量是线程不安全的！

二. 问题复现

public class Test {
    public static void main(String[] args) {
       int total = insertDataToTN(100,1);
       System.out.println("总："+total); // 输出结果(每次结果不一样)：427775

    }

    public static int insertDataToTN(int threadCount, final int cycleCount){

        class NumRunnable implements Runnable{
            int totalSum = 0;

            public void run(){
                for(int i = 0 ; i<10000;i++){
                    totalSum++;
                }
            }

        }

        NumRunnable numRunnable = new NumRunnable();
        List<Thread> threads = new ArrayList<Thread>();
        for(int i=0;i<threadCount;i++) {
            Thread thread = new Thread(numRunnable,"thread"+i);
            thread.start();
            threads.add(thread);
        }

        for(Thread tThread:threads){
            try {
                tThread.join();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        return numRunnable.totalSum;
    }
}

三. 解决方法

1. 法1：使用原子类AtomicInteger

public class Test {
    public static void main(String[] args) {
        AtomicInteger a = insertDataToTN(100,1);
        System.out.println(a); // 输出结果：1000000
    }

    public static AtomicInteger insertDataToTN(int threadCount, final int cycleCount){

        class NumRunnable implements Runnable{
            AtomicInteger totalSum = new AtomicInteger(0);

            public void run(){
                for(int i = 0 ; i<10000;i++){
                    totalSum.addAndGet(1);
                }
            }
        }

        NumRunnable numRunnable = new NumRunnable();
        List<Thread> threads = new ArrayList<Thread>();
        for(int i=0;i<threadCount;i++) {
            Thread thread = new Thread(numRunnable,"thread"+i);
            thread.start();
            threads.add(thread);
        }

        for(Thread tThread:threads){
            try {
                tThread.join();
            }catch (Exception e){
                e.printStackTrace();
            }
        }

        return numRunnable.totalSum;
    }
}

2. 法2：使用synchronized关键字

public class Test {
    public static void main(String[] args) {
        int total = insertDataToTN(100,1);
        System.out.println("总："+total); // 输出结果：1000000
    }

    public static int insertDataToTN(int threadCount, final int cycleCount){

        class NumRunnable implements Runnable{
             int totalSum = 0;

            public void run(){
                for(int i = 0 ; i<10000;i++){
                    add();
                }
            }

            public synchronized void add(){
                totalSum++;
            }

        }

        NumRunnable numRunnable = new NumRunnable();
        List<Thread> threads = new ArrayList<Thread>();
        for(int i=0;i<threadCount;i++) {
            Thread thread = new Thread(numRunnable,"thread"+i);
            thread.start();
            threads.add(thread);
        }

        for(Thread tThread:threads){
            try {
                tThread.join();
            }catch (Exception e){
                e.printStackTrace();
            }
        }

        return numRunnable.totalSum;

    }
}