java高并发

// Java高并发示例代码：使用线程池和锁机制

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

public class HighConcurrencyExample {

    // 定义一个共享资源
    private static int sharedResource = 0;
    // 定义一个锁对象，用于同步访问共享资源
    private static final ReentrantLock lock = new ReentrantLock();

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

        // 提交多个任务到线程池
        for (int i = 0; i < 100; i++) {
            executorService.submit(() -> {
                try {
                    // 尝试获取锁
                    lock.lock();
                    try {
                        // 模拟对共享资源的操作
                        int temp = sharedResource;
                        Thread.sleep(1); // 模拟耗时操作
                        sharedResource = temp + 1;
                    } finally {
                        // 确保锁会被释放
                        lock.unlock();
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // 关闭线程池
        executorService.shutdown();
        try {
            // 等待所有任务完成
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                executorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            executorService.shutdownNow();
        }

        // 输出最终的共享资源值
        System.out.println("Final shared resource value: " + sharedResource);
    }
}

解释说明：

1. 线程池：使用Executors.newFixedThreadPool(10)创建了一个包含10个线程的线程池，避免了频繁创建和销毁线程带来的开销。
2. ReentrantLock：使用ReentrantLock来确保多个线程在访问共享资源时不会发生冲突。每次只有一个线程能够获取到锁，从而保证了线程安全。
3. 共享资源：sharedResource是一个共享变量，多个线程会同时对其进行读取和写入操作。为了防止数据不一致问题，必须对其进行同步保护。
4. try-finally：确保无论是否发生异常，锁都会被正确释放。
5. Thread.sleep：模拟耗时操作，增加了并发竞争的可能性。
6. shutdown 和 awaitTermination：确保主线程等待所有子线程执行完毕后再输出结果。

这段代码展示了如何在高并发环境下使用线程池和锁机制来保证程序的正确性和性能。