线程上下文切换

线程上下文切换（Thread Context Switch ）

定义

CPU执行线程的时候是通过时间分片的方式来轮流执行的，当某一个线程的时间片用完（到期），那么这个线程就会被中断，CPU不再执行当前线程，CPU会把使用权给其它线程来执行。如T1线程未执行结束，T2/T3线程插进来执行了，若干时间后T1又继续执行未执行完的部分，这种就造成了线程之间的来回切换。

一次上下文切换：CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再次加载这个任务的状态，从任务保存到再加载的过程就是一次上下文切换。当Context Switch发生时，需要由操作系统保持当前线程的状态，并恢复另一个线程的状态，状态包括程序计数器、虚拟机栈中每个栈帧的信息。

造成原因

线程的CPU时间片用完
垃圾回收
有更高优先级的线程需要运行
线程自已调用了sleep、yield、wait、park、synchronized、lock等方法

并发编程的目的是为了让程序运行得更快，但是并不是启动更多的线程就能让程序最大限度地并发执行。在进行并发编程时，如果希望通过多线程执行任务让程序运行得更快，会面临非常多的挑战，比如上下文切换的问题、死锁的问题，以及受限于硬件和软件的资源限制问题，本文要研究的是上下文切换的问题。

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

代码演示：

public class LockSupportTest {

    public static void main(String[] args) throws InterruptedException {
        contextSwitchTest();
    }

    public static long count = 0;
    
    //
    public static void contextSwitchTest() {
        long start = System.currentTimeMillis();
        // 启动10000个线程，表示有10000个线程会来回上下文切换
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                synchronized (LockSupportTest.class) {
                    for (int j = 0; j < 10000; j++) {
                        count++;
                    }
                }
            }, "AAA").start();
        }
        // 主线程 + 后台gc线和，所以这里判断条件为2
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        long end = System.currentTimeMillis();
        System.out.println("最终结果：" + count + "共执行：" + (end - start) + "ms"); // 最终结果：100000000共执行：539ms
    }

    public static void synchronizedTest() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000 * 10000; i++) {
            synchronized (LockSupportTest.class) {
                count++;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("最终结果：" + count + "共执行：" + (end - start) + "ms"); // 最终结果：100000000共执行：567ms
    }

    public static void noSwitchtest() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000 * 10000; i++) {
            count++;
        }
        long end = System.currentTimeMillis();
        System.out.println("最终结果：" + count + "共执行：" + (end - start) + "ms"); // 最终结果：100000000共执行：4ms
    }
}

上面3种测试都是计算10000*10000次++操作，单个线程下执行只需要4ms，而10000个线程的情况下执行1422ms。由此可见线程上下文切换带来的性能消耗是很大的。而单线程情况下使用synchronized关键字，也需要567ms。

如何减少上下文切换

既然上下文切换会导致额外的开销，因此减少上下文切换次数便可以提高多线程程序的运行效率。减少上下文切换的方法有无锁并发编程、CAS算法、使用最少线程和使用协程。

无锁并发编程。多线程竞争时，会引起上下文切换，所以多线程处理数据时，可以用一些办法来避免使用锁，如将数据的ID按照Hash取模分段，不同的线程处理不同段的数据
CAS算法。Java的Atomic包使用CAS算法来更新数据，而不需要加锁
使用最少线程。避免创建不需要的线程，比如任务很少，但是创建了很多线程来处理，这样会造成大量线程都处于等待状态
协程。在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换