线程池使用不合理搞崩系统你见过吗？看我这篇就够了！

资源耗尽：
内存消耗增加：每个线程都会占用一定的堆栈空间，
线程数过多可能导致内存消耗过大，
甚至引发OutOfMemoryError。

CPU资源过度分配：
过多的线程会导致CPU过度调度，
增加上下文切换的频率，
降低CPU的利用率和整体系统的吞吐量。

性能下降：
上下文切换开销：
频繁的上下文切换会消耗大量的CPU时间，
降低线程的实际执行效率。

I/O等待：
如果线程执行的任务涉及I/O操作，
过多的线程在等待I/O完成时会占用更多的系统资源，
如文件句柄、网络连接等。

系统稳定性受影响：
死锁风险增加：
大量线程并发执行时，
资源竞争更加激烈，
增加了死锁的风险。

系统响应时间变长：
过多的线程导致系统调度负担加重，
响应用户请求的时间可能会显著增加。

管理复杂度提升：
监控和调试难度加大：
线程数过多使得跟踪和分析线程状态变得更加困难，
增加了问题定位和故障排查的复杂度。

//多个读取线程 和 一个写入线程 同时访问  共享的列表list。
//由于读取和写入都需要获取列表的锁，
//可能会导致读取线程和写入线程之间的资源争用，
//从而降低性能。


class YYExample {
    private static List<Integer> list = new ArrayList<>();
 
    public static void main(String[] args) {
        Runnable reader = () -> {
            while (true) {
                synchronized (list) {
                    for (Integer value : list) {
                        // 读取共享列表
                        System.out.println(value);
                    }
                }
            }
        };
 
        Runnable writer = () -> {
            while (true) {
                synchronized (list) {
                    // 写入共享列表
                    list.add(1);
                }
            }
        };
 
        // 创建多个读取线程和写入线程
        for (int i = 0; i < 50; i++) {
            new Thread(reader).start();
        }
        new Thread(writer).start();
    }
}

class DemoExample {
    private static Object resource1 = new Object();
    private static Object resource2 = new Object();
 
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1 acquired resource 1");
                synchronized (resource2) {
                    System.out.println("Thread 1 acquired resource 2");
                }
            }
        });
 
        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2 acquired resource 2");
                synchronized (resource1) {
                    System.out.println("Thread 2 acquired resource 1");
                }
            }
        });
 
        thread1.start();
        thread2.start();
    }
}

class Counter {
    private int count;
 
    public void increment() {
        count++;
    }
 
    public int getCount() {
        return count;
    }
}

在没有同步机制的情况下，
多个线程并发执行 `increment()` 方法可能导致竞态条件，
从而导致最终的计数结果不正确。

public class Task implements Runnable {
    @Override
    public void run() {
        try {
            // 执行可能抛出异常的任务
            doSomething();
        } catch (Exception e) {
            // 异常处理逻辑，如记录日志、发送警报等
            System.err.println("Task failed due to: " + e.getMessage());
            e.printStackTrace();
        }
    }

    private void doSomething() throws Exception {
        // 可能抛出异常的代码
    }
}

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<?> future = executor.submit(new Task());

try {
    future.get(); // 这里会抛出任务中抛出的异常
} catch (ExecutionException e) {
    // 获取并处理原始异常
    Throwable cause = e.getCause();
    System.err.println("Task failed due to: " + cause.getMessage());
} catch (InterruptedException e) {
    // 处理中断异常
}

Thread thread = new Thread(new Task());
thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
    public void uncaughtException(Thread t, Throwable e) {
        // 异常处理逻辑
        System.err.println(t.getName() + " throws an exception: " + e.getMessage());
    }
});
thread.start();

ThreadFactory factory = new ThreadFactoryBuilder()
    .setUncaughtExceptionHandler((t, e) -> {
        System.err.println(t.getName() + " throws an exception: " + e.getMessage());
    })
    .build();

ExecutorService executor = Executors.newFixedThreadPool(10, factory);