线程安全问题（线程不安全因素）

Youcan.

已于 2022-08-14 19:52:18 修改

阅读量1.3k

点赞数 7

分类专栏： Java JavaEE 文章标签： java java-ee intellij-idea

于 2022-03-29 09:33:09 首次发布

本文链接：https://blog.csdn.net/m0_48273471/article/details/123808099

版权

Java 同时被 2 个专栏收录

76 篇文章 3 订阅

订阅专栏

JavaEE

41 篇文章 2 订阅

订阅专栏

线程不安全指的是程序在多线程的执行结果不符合预期。

单线程：

public class ThreadDemoCounter2 {
    static class Counter {
        private int num = 0;
        public void incr(int count) {
            for (int i = 0; i < count; i++) {
                num++;
            }
        }

        public void decr(int count) {
            for (int i = 0; i < count; i++) {
                num--;
            }
        }
        
        public int getNum() {
            return num;
        }
    }

    public static void main(String[] args) {
        int count = 100000;
        Counter counter = new Counter();
        counter.incr(count);
        counter.decr(count);
        System.out.println(counter.getNum());
    }
}

输出：
0

多线程：

public class ThreadDemoCounter3 {
    static class Counter {
        private int num  = 0;

        public void incr(int count) {
            for (int i = 0; i < count; i++) {
                num++;
            }
        }

        public void decr(int count) {
            for (int i = 0; i < count; i++) {
                num--;
            }
        }

        public int getNum() {
            return num;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        int count = 10000;
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            counter.incr(count);
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            counter.decr(count);
        });
        t2.start();

        t1.join();
        t2.join();

        System.out.println(counter.getNum());
    }
}

输出：
最终结果：0

1. 抢占式执行（狼多肉少）

2. 多个线程修改同一个变量

public class ThreadDemoCounter4 {
    static class Counter {
        int num  = 0;

        public int incr(int count) {
            for (int i = 0; i < count; i++) {
                num++;
            }
            return num;
        }

        public int decr(int count) {
            for (int i = 0; i < count; i++) {
                num--;
            }
            return num;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        int count = 10000;
       Counter counter = new Counter();

       final int[] num1 = new int[1];
        Thread t1 = new Thread(() -> {
            num1[0] = counter.incr(count);
        });
        t1.start();

        final int[] num2 = new int[1];
        Thread t2 = new Thread(() -> {
            num2[0] = counter.decr(count);
        });
        t2.start();

        t1.join();
        t2.join();

        System.out.println(num1[0] + num2[0]);
    }
}
   

输出：
100000

3. 非原子性操作

给房间加⼀把锁，A 进去就把⻔锁上，其他⼈就进不来，这样就保证了代码的原⼦性。有时也把这个现象叫做同步互斥，表示操作是互相排斥的。

⼀条 java 语句不⼀定是原⼦的，也不⼀定只是⼀条指令。

num++ 实际上是由散步操作组成的：

a . 从内存把数据读到 CPU

b. 进⾏数据更新

c. 把数据写回到 CPU

不保证原⼦性：如果⼀个线程正在对⼀个变量操作，中途其他线程插⼊进来了，如果这个操作被打断了，结果就可能是错误的。

public class ThreadDemoCounter5 {
    static class Counter {
        private int num  = 0;

        public void incr(int count) {
            for (int i = 0; i < count; i++) {
                num++;
            }
        }

        public void decr(int count) {
            for (int i = 0; i < count; i++) {
                num--;
            }
        }

        public int getNum() {
            return num;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        int count = 10000;
        ThreadDemoCounter3.Counter counter = new ThreadDemoCounter3.Counter();
        Thread t1 = new Thread(() -> {
            counter.incr(count);
        });
        t1.start();
        t1.join();

        Thread t2 = new Thread(() -> {
            counter.decr(count);
        });
        t2.start();
        t2.join();

        System.out.println(counter.getNum());
    }
}

输出
0

4. 内存可见性

即就是，⼀个线程对共享变量值的修改，能够及时地被其他线程看到。

public class ThreadDemoCounter6 {
    private static boolean flag = true;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("线程1：开始执行" + LocalDateTime.now());

            while(flag ) {
            }
            System.out.println("线程1：结束执行" + LocalDateTime.now());
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2：修改flag = false" + LocalDateTime.now());
            flag = false;
        });
        t2.start();
    }
}

输出：
线程1：开始执行2022-03-29T09:20:29.894
线程2：修改flag = false2022-03-29T09:20:30.856

可以发现·，线程2修改全局变量之后，理论上，线程1应该结束，并输出“线程1：结束执行 + 时间”，但线程1却在一直在执行，并没有感知到全局变量flag的变化，这就是内存可见性问题。

Java 内存模型 (JMM):