多线程开发中的优化技巧：ExecutorService管理线程池与避免死锁

import java.util.concurrent.*;

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

        // 提交多个任务到线程池
        for (int i = 1; i <= 5; i++) {
            final int taskId = i;
            executorService.submit(() -> {
                System.out.println("Task " + taskId + " is being processed by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

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

Task 1 is being processed by pool-1-thread-1
Task 2 is being processed by pool-1-thread-2
Task 3 is being processed by pool-1-thread-3
Task 4 is being processed by pool-1-thread-1
Task 5 is being processed by pool-1-thread-2

ExecutorService executorService = new ThreadPoolExecutor(
        2, // 核心线程数
        4, // 最大线程数
        60L, TimeUnit.SECONDS, // 线程空闲时间
        new LinkedBlockingQueue<>(10) // 阻塞队列容量
);

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

public class DeadlockExample {
    private final Lock lock1 = new ReentrantLock();
    private final Lock lock2 = new ReentrantLock();

    public void method1() {
        lock1.lock();
        try {
            Thread.sleep(100);  // 模拟任务执行
            lock2.lock();
            try {
                System.out.println("method1 executed");
            } finally {
                lock2.unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock1.unlock();
        }
    }

    public void method2() {
        lock2.lock();
        try {
            Thread.sleep(100);  // 模拟任务执行
            lock1.lock();
            try {
                System.out.println("method2 executed");
            } finally {
                lock1.unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock2.unlock();
        }
    }

    public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        Thread thread1 = new Thread(example::method1);
        Thread thread2 = new Thread(example::method2);
        
        thread1.start();
        thread2.start();
    }
}