并发编程基础知识点

上下文切换

CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个
任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这个任务的状态。所以任务从保存到再加载的过程就是一次上下文切换。

这就像我们同时读两本书，当我们在读一本英文的技术书时，发现某个单词不认识，于是便打开中英文字典，但是在放下英文技术书之前，大脑必须先记住这本书读到了多少页的第多少行，等查完单词之后，能够继续读这本书。这样的切换是会影响读书效率的，同样上下文切换也会影响多线程的执行速度。

线程的优势

1、发挥多处理器的强大能力。可以使多线程在不同的CPU上执行，充分利用多CPU的优势。
2、能够充分的利用cpu空闲时间。比如当程序在等待某个IO操作，完成时，CPU将出于空闲状态，这时CPU可以运行别的线程，提高CPU的利用率。
3、简化开发流程，可以使用不同的线程开发不同的业务功能，代码逻辑更清晰。

线程带来的风险

1、安全性问题。
安全性问题其实就是线程安全性，这一点是非常复杂的，因为在没有同步的情况下，多个线程同时执行，执行顺序是不可预测的，可能会出现奇怪的结果。
2、活跃性问题。
关注的是某件正确事情最终会发生。由于线程的引入，会出现A线程在等待线程B释放其持有的资源，而B线程永远都不释放该资源，那么A就永久的无法执行。
3、性能问题。
在多线程中，线程调度器临时挂起活跃线程转而运行另一个线程就会出现上下文切换，会保存和恢复执行上下文，让cpu会开销在线程调度上而不是运行商。

Daemon线程

Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这
意味着，当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会退出。可以通过调用Thread.setDaemon(true)将线程设置为Daemon线程。

注意　Daemon属性需要在启动线程之前设置，不能在启动线程之后设置。

Daemon线程被用作完成支持性工作，但是在Java虚拟机退出时Daemon线程中的finally块
并不一定会执行，示例如下代码所示。

public class Daemon {
    public static void main(String[] args) {
        Thread thread = new Thread(new DaemonRunner(), "DaemonRunner");
        thread.setDaemon(true);
        thread.start();
    }
    
    static class DaemonRunner implements Runnable {
        @Override
        public void run() {
            try {
                SleepUtils.second(10);
            } finally {
                System.out.println("DaemonThread finally run.");
            }
        }
    }
}

运行Daemon程序，可以看到在终端或者命令提示符上没有任何输出。main线程（非
Daemon线程）在启动了线程DaemonRunner之后随着main方法执行完毕而终止，而此时Java虚拟机中已经没有非Daemon线程，虚拟机需要退出。Java虚拟机中的所有Daemon线程都需要立即终止，因此DaemonRunner立即终止，但是DaemonRunner中的finally块并没有执行。

注意　在构建Daemon线程时，不能依靠finally块中的内容来确保执行关闭或清理资源
的逻辑。

线程安全

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。

线程安全问题都是由全局变量及静态变量引起的。 若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全。

原子操作

原子（atom）本意是“不能被进一步分割的最小粒子”，而原子操作（atomic operation）意为"不可被中断的一个或一系列操作" 。
例如 count=5

下面的两个例子在java中不是原子操作
反例1：

  count++;

看上去只是一个操作，但这个操作并不是原子操作。实际上它包含了三个独立的操作

1. 读取count的值
2. 将count值加1
3. 将计算结果写入count。

这是一个读取、修改、写入的操作序列，并且其结果依赖于之前的状态。

反例2：

    private Object obj = new Object();

该操作可以分解成如下3个步骤：

1. 分配对象的内存空间
2. 初始化对象
3. 设置obj 指向刚分配的内存地址

java中原子操作
示例1：

    synchronized(this){
        count++;
    }

通过加锁方式实现原子操作。

示例2：

    private volatile Object obj = new Object();

通过volatile 实现原子操作

竞态条件

当某个计算的正确性取决于多个线程的交替执行顺序时，那么就会发生静态条件。
例如下面例子：

public class RaceCondition {
    private int count = 0;
    public void add(int num){
        this.count = this.count + num;
    }
}

多线程在执行add方法时，就会出现竞态条件。
根据上面原子操作中的示例，把 this.count = this.count + num; 分解成三步（其实机器码不止三步，这里只是为了说明产生竞态条件）

1. 读取count的值
2. 将count值加上num
3. 将计算结果写入count。

下面通过分析2个线程同时并发访问add方法可能执行的顺序。

顺序	执行步骤
1	A: 从主内存中读取 this.count 到工作内存 (0)
2	B: 从主内存中读取 this.count 到工作内存 (0)
3	B: 将工作内存中的值加2
4	B: 回写工作内存中的值(2)到主内存. this.count 现在等于 2
5	A: 将工作内存中的值加3
6	A: 回写工作内存中的值(3)到主内存. this.count 现在等于 3

两个线程分别在count变量上加了2和3，两个线程执行结束后count变量的值应该等于5。然而由于两个线程是交叉执行的，两个线程从内存中读出的初始值都是0。然后各自加了2和3，并分别写回内存。最终的值并不是期望的5，而是最后写回内存的那个线程的值，上面例子中最后写回内存的是线程A，但实际中也可能是线程B。如果没有采用合适的同步机制，线程间的交叉执行情况就无法预料。
这样执行结果依赖多线程的交替执行顺序而使得结果不确定，可能是2、3、5三种结果。

临界区

，add方法就是临界区。
导致竞态条件发生的代码区称作临界区。上面竞态条件中例子中的add()方法就是一个临界区,它会产生竞态条件。在临界区中使用适当的同步就可以避免竞态条件。

参考和摘抄java并发编程艺术、java并发编程艺术

---

想了解更多精彩内容请关注我的公众号