面试官：什么是多线程中的上下文切换？-51CTO.COM

在多线程编程中，“上下文切换”指的是操作系统在不同线程之间切换执行时保存和恢复线程状态的过程。每个线程都包含一个“上下文”，即当前执行的状态信息，包括寄存器的值、程序计数器（指令位置）、堆栈指针等。

步骤：

保存当前线程的状态：当一个线程被挂起时，操作系统会将该线程的寄存器、程序计数器等状态信息保存到内存中，以便将来能够恢复。
恢复新线程的状态：接下来，操作系统加载即将运行的线程的状态信息，使得该线程能够从中断的位置继续执行。
切换到新线程执行：完成状态的保存和恢复后，CPU就会开始执行新线程的指令。

开销：

虽然上下文切换使得多个线程能够共享CPU资源，但它并非完全没有成本。保存和恢复状态需要时间，频繁的上下文切换会导致：

性能下降：频繁切换会占用大量的CPU时间，导致真正执行任务的时间减少。
缓存失效：每次切换线程时，CPU缓存可能会被刷新，导致缓存效率降低，增加内存访问延迟。

如何减少上下文切换策略？

减少线程数量：

每个线程都需要上下文切换资源，线程越多，切换频率越高。如果任务量不大，减少线程数量可以降低上下文切换的频率。

import java.util.List;
import java.util.Arrays;

public class ReduceThreadsExample {
    public static void main(String[] args) {
        List<String> tasks = Arrays.asList("task1", "task2", "task3", /* ... */ "task100");
        int threadCount = 10;
        int taskPerThread = tasks.size() / threadCount;

        for (int i = 0; i < threadCount; i++) {
            final int start = i * taskPerThread;
            final int end = (i == threadCount - 1) ? tasks.size() : (i + 1) * taskPerThread;

            new Thread(() -> {
                for (int j = start; j < end; j++) {
                    System.out.println("Processing " + tasks.get(j));
                }
            }).start();
        }
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

使用多线程池：

线程池可以复用线程，避免频繁创建和销毁线程，从而减少上下文切换开销。线程池中的线程会被重新分配任务，避免重复的上下文切换。

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 100; i++) {
            int task = i;
            executor.submit(() -> System.out.println("Processing task " + task));
        }

        executor.shutdown();
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

增加任务的批处理：

尽量将多个小任务合并为一个批处理任务，减少线程之间的切换。这样可以在同一个线程中连续完成多个任务，降低切换的频率。

import java.util.List;
import java.util.Arrays;

public class BatchProcessingExample {
    public static void main(String[] args) {
        List<String> tasks = Arrays.asList("task1", "task2", "task3", /* ... */ "task100");
        int batchSize = 10;

        for (int i = 0; i < tasks.size(); i += batchSize) {
            final List<String> batch = tasks.subList(i, Math.min(i + batchSize, tasks.size()));

            new Thread(() -> {
                for (String task : batch) {
                    System.out.println("Processing " + task);
                }
            }).start();
        }
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

尽量减少锁竞争：

当多个线程竞争同一个锁时，线程会频繁等待和唤醒，导致频繁的上下文切换。可以通过优化锁的使用，或者采用更细粒度的锁来减少锁的竞争。例如，使用读写锁来避免多个读取线程间的竞争。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockCompetitionExample {
    private static int counter = 0;
    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Counter: " + counter);
    }

    private static void increment() {
        lock.lock();
        try {
            counter++;
        } finally {
            lock.unlock();
        }
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.

无锁编程：

在适用的场景下，使用无锁编程（如原子操作或CAS操作）来实现线程间的同步，避免因为锁竞争而产生的上下文切换。这通常适用于轻量级的并发操作。

import java.util.concurrent.atomic.AtomicInteger;

public class LockFreeExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.incrementAndGet();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Counter: " + counter.get());
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.

使用协程替代多线程：

协程是一种轻量级的“线程”实现，可以在一个线程中实现多任务的协作切换。由于协程的切换是由程序控制的，不需要操作系统参与，因此可以大幅减少上下文切换的开销。JDK21后支持协程。

public class VirtualThreadExample {
    public static void main(String[] args) {
        try (var executor = java.util.concurrent.Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 100; i++) {
                int taskNumber = i;
                executor.submit(() -> {
                    System.out.println("Processing task " + taskNumber + " in " + Thread.currentThread());
                    // 模拟一些I/O操作或其他阻塞任务
                    try {
                        Thread.sleep(1000);  // 模拟任务执行时间
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    return taskNumber;
                });
            }
        }  // 自动关闭 executor，确保所有虚拟线程完成执行
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.