【黑马程序员】Java进阶教程ELK高级搜索_ElasticStack技术栈 – 带源码课件

### 线程池高级配置与优化

Executor框架提供强大的线程管理能力。ThreadPoolExecutor核心参数包括corePoolSize、maximumPoolSize、keepAliveTime、workQueue和handler。合理配置这些参数对系统性能至关重要。

java
下载
复制
运行
// 自定义线程池配置
public class ThreadPoolConfig {
    public static ThreadPoolExecutor createCustomPool() {
        int corePoolSize = Runtime.getRuntime().availableProcessors();
        int maxPoolSize = corePoolSize * 2;
        long keepAliveTime = 60L;
        
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(1000);
        ThreadFactory threadFactory = new CustomThreadFactory();
        RejectedExecutionHandler handler = new CustomRejectionHandler();
        
        return new ThreadPoolExecutor(
            corePoolSize, maxPoolSize, keepAliveTime,
            TimeUnit.SECONDS, workQueue, threadFactory, handler
        );
    }
}

// 自定义线程工厂
class CustomThreadFactory implements ThreadFactory {
    private final AtomicInteger count = new AtomicInteger(1);
    
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setName("custom-pool-" + count.getAndIncrement());
        thread.setPriority(Thread.NORM_PRIORITY);
        thread.setDaemon(false);
        return thread;
    }
}

// 自定义拒绝策略
class CustomRejectionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.err.println("任务被拒绝: " + r.toString());
        // 可在此处添加日志记录或报警逻辑
    }
}

并发工具类实战应用

CountDownLatch用于等待多个线程完成，CyclicBarrier让线程互相等待，Semaphore控制并发访问数量，Exchanger实现线程间数据交换。

java
下载
复制
运行
// 并发工具综合应用
public class ConcurrentToolsDemo {
    private final ExecutorService executor = Executors.newFixedThreadPool(4);
    private final CountDownLatch latch = new CountDownLatch(3);
    private final CyclicBarrier barrier = new CyclicBarrier(3);
    private final Semaphore semaphore = new Semaphore(2);
    
    public void executeTasks() {
        for (int i = 0; i < 3; i++) {
            executor.submit(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + " 获得许可");
                    
                    barrier.await(); // 等待所有线程就绪
                    // 执行具体任务
                    Thread.sleep(1000);
                    
                    latch.countDown();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            });
        }
        
        try {
            latch.await(); // 等待所有任务完成
            System.out.println("所有任务完成");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}