如何用Java多线程处理并发请求

在Java中，使用多线程处理并发请求是一种常见的做法，可以显著提高应用程序的性能和响应能力。以下是一个基本的指南，介绍如何使用Java多线程来处理并发请求。

1. 创建线程池

使用java.util.concurrent.ExecutorService来创建和管理线程池。线程池可以有效地管理线程的生命周期，避免频繁地创建和销毁线程。

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        // 提交任务到线程池
        for (int i = 0; i < 100; i++) {
            final int taskNumber = i;
            executorService.submit(() -> {
                System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
                // 模拟任务执行时间
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("Task " + taskNumber + " is completed");
            });
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

2. 使用Callable和Future

如果你需要从任务中返回结果，可以使用Callable接口和Future对象。

import java.util.concurrent.*;

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

        // 创建一个Callable任务
        Callable<Integer> task = () -> {
            System.out.println("Task is running on thread " + Thread.currentThread().getName());
            // 模拟任务执行时间
            Thread.sleep(1000);
            return 42;
        };

        try {
            // 提交任务并获取Future对象
            Future<Integer> future = executorService.submit(task);

            // 获取任务结果
            Integer result = future.get();
            System.out.println("Task result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

3. 使用CompletableFuture

CompletableFuture提供了更强大的异步编程能力，可以更方便地处理任务的组合和异常处理。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
    public static void main(String[] args) {
        // 创建一个CompletableFuture任务
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Task is running on thread " + Thread.currentThread().getName());
            // 模拟任务执行时间
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return 42;
        });

        // 处理任务结果
        future.thenAccept(result -> System.out.println("Task result: " + result));

        // 等待任务完成
        try {
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4. 使用同步工具类

Java提供了许多同步工具类，如CountDownLatch、CyclicBarrier和Semaphore，可以帮助你更好地控制并发任务的执行。

CountDownLatch

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) {
        int numberOfTasks = 5;
        CountDownLatch latch = new CountDownLatch(numberOfTasks);

        for (int i = 0; i < numberOfTasks; i++) {
            new Thread(() -> {
                System.out.println("Task is running on thread " + Thread.currentThread().getName());
                // 模拟任务执行时间
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("Task is completed");
                latch.countDown();
            }).start();
        }

        try {
            // 等待所有任务完成
            latch.await();
            System.out.println("All tasks are completed");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

CyclicBarrier

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        int numberOfThreads = 5;
        CyclicBarrier barrier = new CyclicBarrier(numberOfThreads, () -> {
            System.out.println("All threads have reached the barrier");
        });

        for (int i = 0; i < numberOfThreads; i++) {
            new Thread(() -> {
                System.out.println("Thread " + Thread.currentThread().getName() + " is waiting at the barrier");
                try {
                    barrier.await();
                    System.out.println("Thread " + Thread.currentThread().getName() + " has crossed the barrier");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        int numberOfPermits = 3;
        Semaphore semaphore = new Semaphore(numberOfPermits);

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println("Thread " + Thread.currentThread().getName() + " has acquired the permit");
                    // 模拟任务执行时间
                    Thread.sleep(1000);
                    System.out.println("Thread " + Thread.currentThread().getName() + " is releasing the permit");
                    semaphore.release();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }).start();
        }
    }
}

通过这些方法，你可以有效地使用Java多线程来处理并发请求，提高应用程序的性能和响应能力。