Java实现多线程高并发简单案例

案例：高并发计数器

import java.util.concurrent.*;

public class HighConcurrencyCounter {
    // 使用原子变量提供线程安全的计数功能
    private static final AtomicInteger counter = new AtomicInteger(0);
    
    // 模拟任务类
    public static class Task implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                counter.incrementAndGet();
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        // 设置任务数量和线程池大小
        int taskCount = 1000; // 总任务数
        int poolSize = Runtime.getRuntime().availableProcessors(); // 使用CPU核心数作为线程池大小
        
        // 创建线程池
        ExecutorService executor = new ThreadPoolExecutor(
            poolSize, // 核心线程数
            poolSize * 2, // 最大线程数
            60L, // 空闲线程存活时间
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1000), // 任务队列
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );
        
        // 提交任务
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < taskCount; i++) {
            executor.submit(new Task());
        }
        
        // 关闭线程池并等待所有任务完成
        executor.shutdown();
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        
        long endTime = System.currentTimeMillis();
        
        // 输出结果
        System.out.println("Expected count: " + (taskCount * 1000));
        System.out.println("Actual count: " + counter.get());
        System.out.println("Total time: " + (endTime - startTime) + " ms");
    }
}

案例：高并发Web请求处理

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class HighConcurrencyWebServer {
    // 模拟请求处理
    public static class RequestHandler implements Runnable {
        private final AtomicInteger requestCounter;
        
        public RequestHandler(AtomicInteger requestCounter) {
            this.requestCounter = requestCounter;
        }
        
        @Override
        public void run() {
            try {
                // 模拟处理请求的耗时操作
                Thread.sleep(100);
                
                // 更新计数器
                requestCounter.incrementAndGet();
                
                // 模拟响应客户端
                System.out.println("Request processed by thread: " + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        int numberOfRequests = 1000; // 总请求数
        AtomicInteger processedRequests = new AtomicInteger(0);
        
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        // 提交请求处理任务
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < numberOfRequests; i++) {
            executor.submit(new RequestHandler(processedRequests));
        }
        
        // 等待所有任务完成
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);
        
        long endTime = System.currentTimeMillis();
        
        // 输出结果
        System.out.println("Total requests processed: " + processedRequests.get());
        System.out.println("Total time taken: " + (endTime - startTime) + " ms");
    }
}

案例：生产者-消费者模式的高并发实现

import java.util.concurrent.*;

public class ProducerConsumerExample {
    // 共享缓冲区
    public static class Buffer {
        private final BlockingQueue queue;
        private final int capacity;
        
        public Buffer(int capacity) {
            this.capacity = capacity;
            this.queue = new ArrayBlockingQueue<>(capacity);
        }
        
        public void produce(int value) throws InterruptedException {
            // 当队列满时会阻塞
            queue.put(value);
            System.out.println("Produced: " + value);
        }
        
        public int consume() throws InterruptedException {
            // 当队列空时会阻塞
            int value = queue.take();
            System.out.println("Consumed: " + value);
            return value;
        }
    }
    
    // 生产者线程
    public static class Producer implements Runnable {
        private final Buffer buffer;
        private final int productionCount;
        
        public Producer(Buffer buffer, int productionCount) {
            this.buffer = buffer;
            this.productionCount = productionCount;
        }
        
        @Override
        public void run() {
            try {
                for (int i = 0; i < productionCount; i++) {
                    buffer.produce(i);
                    Thread.sleep(10); // 模拟生产耗时
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    
    // 消费者线程
    public static class Consumer implements Runnable {
        private final Buffer buffer;
        private final int consumptionCount;
        
        public Consumer(Buffer buffer, int consumptionCount) {
            this.buffer = buffer;
            this.consumptionCount = consumptionCount;
        }
        
        @Override
        public void run() {
            try {
                for (int i = 0; i < consumptionCount; i++) {
                    buffer.consume();
                    Thread.sleep(15); // 模拟消费耗时
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        int bufferCapacity = 10; // 缓冲区大小
        int productionCount = 1000; // 每个生产者生产的数量
        int consumptionCount = 1000; // 每个消费者消费的数量
        
        Buffer buffer = new Buffer(bufferCapacity);
        
        // 创建线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        
        // 启动多个生产者和消费者
        for (int i = 0; i < 5; i++) {
            executor.submit(new Producer(buffer, productionCount));
        }
        for (int i = 0; i < 3; i++) {
            executor.submit(new Consumer(buffer, consumptionCount));
        }
        
        // 等待所有任务完成
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);
    }
}

总结

以上三个案例展示了不同场景下的Java多线程高并发实现方式：

1. 第一个案例展示了如何使用原子变量和线程池来处理大量并发计数任务

2. 第二个案例模拟了一个高并发Web服务器，展示了如何处理大量并发请求

3. 第三个案例实现了生产者-消费者模式，展示了如何在高并发环境下安全地共享资源

在实际开发中，使用线程池、原子操作类和线程安全的集合类是处理高并发的关键。