Java并发01：为什么需要并发编程 - 从单线程到多线程的演进

public class SimpleWebServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("服务器启动，监听端口 8080...");

        while (true) {
            // 接受客户端连接
            Socket client = serverSocket.accept();

            // 处理请求（耗时操作）
            handleRequest(client);

            // 关闭连接
            client.close();
        }
    }

    private static void handleRequest(Socket client) throws IOException {
        // 读取请求
        BufferedReader in = new BufferedReader(
            new InputStreamReader(client.getInputStream()));
        String request = in.readLine();

        // 模拟业务处理：查询数据库、调用外部API等（耗时500ms）
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // 返回响应
        PrintWriter out = new PrintWriter(client.getOutputStream(), true);
        out.println("HTTP/1.1 200 OK");
        out.println("Content-Type: text/plain");
        out.println();
        out.println("Hello, World!");
    }
}

public Response handleRequest(Request request) {
    // 1. CPU计算（1ms）
    String userId = parseUserId(request);  // CPU: 1ms

    // 2. 查询数据库（100ms）
    User user = database.query(userId);    // IO:  100ms ← CPU等待！

    // 3. 调用外部API（200ms）
    Order order = api.getOrder(userId);    // IO:  200ms ← CPU等待！

    // 4. 生成响应（1ms）
    return buildResponse(user, order);     // CPU: 1ms

    // 总耗时：302ms
    // CPU实际工作：2ms (0.66%)
    // CPU等待IO：300ms (99.34%)
}

// ❌ 单线程：CPU利用率低
public void processOrders() {
    for (Order order : orders) {
        processOrder(order);  // 处理完一个才处理下一个
    }
}

// ✅ 多线程：提高CPU利用率
public void processOrdersConcurrently() {
    ExecutorService executor = Executors.newFixedThreadPool(10);
    for (Order order : orders) {
        executor.submit(() -> processOrder(order));  // 同时处理多个
    }
    executor.shutdown();
}

// ❌ 同步处理：用户等待3秒
public OrderResult createOrder(Order order) {
    // 1. 扣减库存（1秒）
    inventoryService.deduct(order.getProductId());

    // 2. 生成订单（1秒）
    orderService.create(order);

    // 3. 发送短信（1秒）
    smsService.send(order.getPhone(), "订单创建成功");

    return new OrderResult("success");
}

// ✅ 异步处理：用户等待0.1秒
public OrderResult createOrderAsync(Order order) {
    // 1. 扣减库存（必须同步，0.1秒）
    inventoryService.deduct(order.getProductId());

    // 2. 异步生成订单（不阻塞）
    CompletableFuture.runAsync(() ->
        orderService.create(order));

    // 3. 异步发送短信（不阻塞）
    CompletableFuture.runAsync(() ->
        smsService.send(order.getPhone(), "订单创建成功"));

    return new OrderResult("success");  // 立即返回
}

// ❌ 单线程：只用1个核心，8核CPU利用率12.5%
public long sumArray(int[] array) {
    long sum = 0;
    for (int num : array) {
        sum += num;
    }
    return sum;
}

// ✅ 并行流：使用多个核心，8核CPU利用率接近100%
public long sumArrayParallel(int[] array) {
    return Arrays.stream(array)
                 .parallel()  // 并行处理
                 .sum();
}

public class AmdahlLawCalculator {
    public static void main(String[] args) {
        double P = 0.9;  // 90%可并行

        System.out.println("核心数 | 加速比 | 实际耗时 | CPU利用率");
        System.out.println("------|--------|---------|----------");

        for (int N : new int[]{1, 2, 4, 8, 16, 32, 64, 128}) {
            double speedup = 1.0 / ((1 - P) + P / N);
            double time = 100 / speedup;
            double cpuUtil = (speedup / N) * 100;
            System.out.printf("%6d | %6.2fx | %6.2fs | %6.1f%%\n",
                             N, speedup, time, cpuUtil);
        }
    }
}

// ❌ 错误：直接增加线程数，但串行部分太多
ExecutorService executor = Executors.newFixedThreadPool(100);  // 100线程
for (Order order : orders) {
    executor.submit(() -> {
        synchronized(this) {  // ← 串行瓶颈！
            processOrder(order);
        }
    });
}

// ✅ 正确：先减少串行部分，再并行化
ExecutorService executor = Executors.newFixedThreadPool(10);
for (Order order : orders) {
    executor.submit(() -> {
        processOrder(order);  // 无锁，真正并行
    });
}

// 问题：多个线程同时修改共享变量
public class Counter {
    private int count = 0;

    public void increment() {
        count++;  // ← 不是原子操作！
    }
}

// 结果：100个线程各执行1000次，期望100000，实际可能是99573

// 性能测试：上下文切换的成本
public class ContextSwitchTest {
    public static void main(String[] args) throws InterruptedException {
        // 场景1：单线程循环
        long start1 = System.nanoTime();
        int sum1 = 0;
        for (int i = 0; i < 1000000; i++) {
            sum1 += i;
        }
        long time1 = System.nanoTime() - start1;

        // 场景2：10个线程，每个循环100000次
        ExecutorService executor = Executors.newFixedThreadPool(10);
        long start2 = System.nanoTime();
        CountDownLatch latch = new CountDownLatch(10);
        for (int t = 0; t < 10; t++) {
            executor.submit(() -> {
                int sum = 0;
                for (int i = 0; i < 100000; i++) {
                    sum += i;
                }
                latch.countDown();
            });
        }
        latch.await();
        long time2 = System.nanoTime() - start2;
        executor.shutdown();

        System.out.println("单线程耗时：" + time1 / 1000000.0 + "ms");
        System.out.println("多线程耗时：" + time2 / 1000000.0 + "ms");
        System.out.println("多线程 / 单线程：" + (double)time2 / time1);
    }
}

// 错误示例：为简单任务创建线程，得不偿失
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.parallelStream()  // ← 数据太少，并行反而慢
       .map(n -> n * 2)
       .collect(Collectors.toList());

// 错误示例：步骤之间有强依赖
step1();  // 必须先执行
step2();  // 依赖step1的结果
step3();  // 依赖step2的结果
// 无法并行

// 错误示例：所有线程竞争同一把锁
synchronized(lock) {
    // 临界区
}
// 实际上变成了串行执行