为神马有线程？这玩意儿在干嘛？？？

回答这个问题，就先要知道一点点计算机的工作方式。

总所周知，计算机有五部分：输入输出、计算器、存储器、控制器。而在计算机内，CPU、内存、I/O之间的运行速度差别十分巨大，因此，为了使这几部分速度平衡、使计算机整体协调起来、提升性能，计算机分别在软硬件上做了努力：

CPU增加缓存，以调节与内存的速度差异（可见性）；操作系统增加进程、线程，分时使用CPU（原子性）；编译器优化了程序的执行次序指令，使得缓存能够更加合理使用（时序性）

由此可见，多线程实际上是在更有效地利用CPU的资源、使得程序运行更流畅

线程不安全示例

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadUnsafeExample {
/**
 * 线程不安全的实例
 * **/
    private int cnt = 0;

    public void add() {
        cnt++;
    }

    public int get() {
        return cnt;
    }
    public static void main(String[] args) throws InterruptedException {
        final int threadSize = 1000;
        ThreadUnsafeExample example = new ThreadUnsafeExample();
        final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < threadSize; i++) {
            executorService.execute(() -> {
                example.add();
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println(example.get());
    }

}

可见，以上几次的运行结果都不相同，这是由于几个线程对共享数据进行操作时是不同步的

继续深入问：以上问题（并发出现问题）的根源是什莫？

** **引出一些概念:**并行与并发不是同一个意思

并行是说进程在同时运行（多在单核CPU环境下）、并发是指一次只进行一个进程

**再引出一些概念：进程、线程、协程间的区别

进程：某个程序对于某个数据集合的一次活动，是操作系统进行资源分配、调度的最小单位，每个进程有自己独立的内存空间，不同的进程间会进行通信

线程：进程的实体，比进程“更小”CPU进行分配的最小单位，其本身不占有系统资源，但和同属于一个进程的其他线程共享进程的资源

协程：

更小，一种用户态的轻量级线程

进程多与线程比较（搜）

线程是指进程内的一个执行单元,也是进程内的可调度实体。线程与进程的区别:

1. 地址空间:线程是进程内的一个执行单元，进程内至少有一个线程，它们共享进程的地址空间，而进程有自己独立的地址空间
2. 资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源
3. 线程是处理器调度的基本单位,但进程不是
4. 二者均可并发执行

5)每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口，但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制

2、协程多与线程进行比较

1. 一个线程可以有多个协程，一个进程也可以单独拥有多个协程，

2. 线程进程都是同步机制，而协程则是异步

3)协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态

回到刚才的问题上： 并发问题的根源

1.可见性

当一个线程对共享变量进行修改，另一个线程应该立刻看到

//线程1执行的代码
int i = 0;
i = 10;
 
//线程2执行的代码
j = i;
在这个例子中，加入CPU1执行线程1，CPU2执行线程2，
当线程1执行 i =10这句时，会先把i的初始值加载到CPU1的高速缓存中，
然后赋值为10，那么在CPU1的高速缓存当中i的值变为10了，却没有立即写入到主存当中。
 此时线程2执行 j = i，它会先去主存读取i的值并加载到CPU2的缓存当中，
注意此时内存当中i的值还是0，那么就会使得j的值为0，而不是10.
 这就是可见性问题，线程1对变量i修改了之后，线程2没有立即看到线程1修改的值。

原子性：

即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

经典的转账问题：比如从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。

试想一下，如果这2个操作不具备原子性，会造成什么样的后果。假如从账户A减去1000元之后，操作突然中止。然后又从B取出了500元，取出500元之后，再执行 往账户B加上1000元 的操作。这样就会导致账户A虽然减去了1000元，但是账户B没有收到这个转过来的1000元。

所以这2个操作必须要具备原子性才能保证不出现一些意外的问题。

有序性：

有序性：即程序执行的顺序按照代码的先后顺序执行。举个简单的例子，看下面这段代码：

int i = 0;              
boolean flag = false;
i = 1;                //语句1  
flag = true;          //语句2

上面代码定义了一个int型变量，定义了一个boolean类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗 不一定，为什么呢 这里可能会发生指令重排序（Instruction Reorder）。

在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序。重排序分三种类型：

• 编译器优化的重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
• 指令级并行的重排序。现代处理器采用了指令级并行技术（Instruction-Level Parallelism， ILP）来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
• 内存系统的重排序。由于处理器使用缓存和读 / 写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。

从 java 源代码到最终实际执行的指令序列，会分别经历下面三种重排序：

上述的 1 属于编译器重排序，2 和 3 属于处理器重排序。这些重排序都可能会导致多线程程序出现内存可见性问题。对于编译器，JMM 的编译器重排序规则会禁止特定类型的编译器重排序（不是所有的编译器重排序都要禁止）。对于处理器重排序，JMM 的处理器重排序规则会要求 java 编译器在生成指令序列时，插入特定类型的内存屏障（memory barriers，intel 称之为 memory fence）指令，通过内存屏障指令来禁止特定类型的处理器重排序（不是所有的处理器重排序都要禁止）。