資源耗盡：
內(nèi)存消耗增加：每個(gè)線程都會(huì)占用一定的堆棧空間，
線程數(shù)過多可能導(dǎo)致內(nèi)存消耗過大，
甚至引發(fā)OutOfMemoryError。

CPU資源過度分配：
過多的線程會(huì)導(dǎo)致CPU過度調(diào)度，
增加上下文切換的頻率，
降低CPU的利用率和整體系統(tǒng)的吞吐量。

性能下降：
上下文切換開銷：
頻繁的上下文切換會(huì)消耗大量的CPU時(shí)間，
降低線程的實(shí)際執(zhí)行效率。

I/O等待：
如果線程執(zhí)行的任務(wù)涉及I/O操作，
過多的線程在等待I/O完成時(shí)會(huì)占用更多的系統(tǒng)資源，
如文件句柄、網(wǎng)絡(luò)連接等。

系統(tǒng)穩(wěn)定性受影響：
死鎖風(fēng)險(xiǎn)增加：
大量線程并發(fā)執(zhí)行時(shí)，
資源競爭更加激烈，
增加了死鎖的風(fēng)險(xiǎn)。

系統(tǒng)響應(yīng)時(shí)間變長：
過多的線程導(dǎo)致系統(tǒng)調(diào)度負(fù)擔(dān)加重，
響應(yīng)用戶請(qǐng)求的時(shí)間可能會(huì)顯著增加。

管理復(fù)雜度提升：
監(jiān)控和調(diào)試難度加大：
線程數(shù)過多使得跟蹤和分析線程狀態(tài)變得更加困難，
增加了問題定位和故障排查的復(fù)雜度。

//多個(gè)讀取線程 和 一個(gè)寫入線程 同時(shí)訪問  共享的列表list。
//由于讀取和寫入都需要獲取列表的鎖，
//可能會(huì)導(dǎo)致讀取線程和寫入線程之間的資源爭用，
//從而降低性能。


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);
                }
            }
        };
 
        // 創(chuàng)建多個(gè)讀取線程和寫入線程
        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;
    }
}

在沒有同步機(jī)制的情況下，
多個(gè)線程并發(fā)執(zhí)行 `increment()` 方法可能導(dǎo)致競態(tài)條件，
從而導(dǎo)致最終的計(jì)數(shù)結(jié)果不正確。

public class Task implements Runnable {
    @Override
    public void run() {
        try {
            // 執(zhí)行可能拋出異常的任務(wù)
            doSomething();
        } catch (Exception e) {
            // 異常處理邏輯，如記錄日志、發(fā)送警報(bào)等
            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(); // 這里會(huì)拋出任務(wù)中拋出的異常
} 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);