并发笔记一：什么是线程不安全？

目录

并发笔记一：什么是线程不安全？
并发笔记二：线程中断机制
并发笔记三：线程的生命周期
并发笔记四：锁机制（一）
并发笔记四：锁机制（二）

1. 概念

线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。<br/>

2. 举个栗子

话不多说，直接上代码

public class ConcurrencyTest {
    //请求总数
    private static int clientTotal = 10000;
    //同时并发执行的线程数
    public static int threadTotal = 200;

    public static int count = 0;

    /**
     *
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();//创建连接池
        /**
         * Semaphore 是 synchronized 的加强版，作用是控制线程的并发数量
         */
        final Semaphore semaphore = new Semaphore(threadTotal);//同步关键类，构造方法传入的数字是多少，则同一个时刻，只运行多少个进程同时运行制定代码
        /**
         *  countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。
         * 通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1
         * 当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。
         */
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);//计数器闭锁

        for (int i = 0; i<clientTotal; i++){
            executorService.execute(() ->{
                try {
                    /**
                     * 在 semaphore.acquire() 和 semaphore.release()之间的代码，同一时刻只允许制定个数的线程进入，
                     * 因为semaphore的构造方法是1，则同一时刻只允许一个线程进入，其他线程只能等待。
                     * */
                    semaphore.acquire();
                    addOne();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
                countDownLatch.countDown();//调用这个方法会使计数器减一，当计数器的值为0时，因调用await()方法被阻塞的线程会被唤醒，继续执行。
            });
        }
        countDownLatch.await();//调用这个方法的线程会被阻塞
        executorService.shutdown();
        System.out.printf("count：" + count);



    }

    private static void addOne(){
        count ++;
    }

}

  这段代码用线程池创建了10000个线程，200个并发同时执行，同时对’i’执行+1操作，基本的注释我都加上去了，应该很容易看懂。

  复制到自己的编译器中执行，会发现最终结果并不等于10000，甚至每次的执行结果都不相同，这是为什么呢？

3. 剥栗子

  ava内存模型的抽象概念图（关于java内存模型，想了解更多的话，去看看此大神的深入理解java内存模型）

  针对上面的例子，当主内存中有一个共享变量‘i=0’的时候，如果线程A、B同时执行，线程A将共享变量’i’取出来放到自己的本地内存A中，对’i’执行 +1 的操作，此时的i仍然在本地内存A中，并未刷新到主内存中，所以线程B从主内存中读取仍为’i=0’(线程A和线程B同时拿到了共享变量‘i’的私有拷贝)，并且在本地内存B中进行+1操作，这个时候本地内存A、B中的i都为1，刷新到主内存后的’i’自然为1。
  这就是一个典型的线程不安全的例子，线程之间没有通信，数据互不可见，造成脏数据。