public class Counter {
    private int count = 0;

    // 使用synchronized修飾方法，確保線程安全
    public synchronized void increment() {
        count++; // 這是一個非原子操作，但在synchronized方法中它是安全的
    }

    public synchronized int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        final Counter counter = new Counter();

        // 創(chuàng)建兩個線程來更新計數(shù)器
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });

        // 啟動線程
        t1.start();
        t2.start();

        // 等待線程完成
        t1.join();
        t2.join();

        // 打印最終計數(shù)器值
        System.out.println("Final count: " + counter.getCount()); // 應(yīng)該是20000
    }
}

public class VolatileExample {
    // 使用volatile修飾共享變量，確保所有線程都能看到最新的值
    private volatile boolean running = true;

    // 啟動一個線程來模擬運行中的任務(wù)
    public void startTask() {
        Thread taskThread = new Thread(() -> {
            while (running) {
                // 模擬任務(wù)執(zhí)行，這里只是簡單地打印信息
                System.out.println("Task is running...");
                try {
                    // 為了演示，讓線程暫停一段時間
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 保持中斷狀態(tài)
                    return;
                }
            }
            System.out.println("Task has stopped.");
        });

        // 啟動線程
        taskThread.start();

        // 假設(shè)在一段時間后，我們想要停止任務(wù)
        try {
            Thread.sleep(5000); // 等待5秒來模擬任務(wù)運行時間
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return;
        }

        // 更新volatile變量以停止任務(wù)
        running = false;
    }

    public static void main(String[] args) {
        VolatileExample example = new VolatileExample();
        example.startTask();

        // 注意：在實際應(yīng)用中，你可能需要等待taskThread真正結(jié)束，這里為了簡化示例而省略了
    }
}

public class WaitNotifyExample {
    private final Object lock = new Object(); // 鎖對象
    private boolean ready = false; // 條件變量

    // 生產(chǎn)者線程調(diào)用此方法
    public void produce() throws InterruptedException {
        synchronized (lock) {
            // 假設(shè)生產(chǎn)者需要做一些準備工作
            System.out.println("Producer is preparing...");
            Thread.sleep(1000); // 模擬耗時操作

            // 準備工作完成，設(shè)置條件變量并通知等待的消費者
            ready = true;
            lock.notify(); // 喚醒等待在該鎖上的一個線程
            System.out.println("Product is ready. Notified consumer.");
        }
    }

    // 消費者線程調(diào)用此方法
    public void consume() throws InterruptedException {
        synchronized (lock) {
            // 等待產(chǎn)品準備好
            while (!ready) {
                lock.wait(); // 釋放鎖并進入等待狀態(tài)
            }

            // 產(chǎn)品已準備好，開始消費
            System.out.println("Consumer is consuming the product.");
            Thread.sleep(1000); // 模擬消費過程

            // 消費完成，重置條件變量供下一輪使用
            ready = false;
        }
    }

    public static void main(String[] args) {
        WaitNotifyExample example = new WaitNotifyExample();

        // 創(chuàng)建生產(chǎn)者線程
        Thread producer = new Thread(() -> {
            try {
                example.produce();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 創(chuàng)建消費者線程
        Thread consumer = new Thread(() -> {
            try {
                example.consume();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 啟動線程
        producer.start();
        consumer.start();

        // 注意：在這個簡單的示例中，沒有等待消費者線程完成。
        // 在實際應(yīng)用中，你可能需要某種形式的同步來確保生產(chǎn)者和消費者之間的正確交互。
    }
}

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

public class CounterWithLock {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 獲取鎖
        try {
            count++;
        } finally {
            lock.unlock(); // 釋放鎖，無論是否發(fā)生異常
        }
    }

    public int getCount() {
        lock.lock(); // 這里也可以考慮使用tryLock()或讀寫鎖等更細粒度的控制
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }

    // main方法和上面的示例類似，只是Counter類被替換為了CounterWithLock類
}

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

public class ConditionExample {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private boolean ready = false;

    // 線程執(zhí)行的任務(wù)
    public void task() throws InterruptedException {
        lock.lock(); // 獲取鎖
        try {
            // 等待條件滿足
            while (!ready) {
                condition.await(); // 釋放鎖并進入等待狀態(tài)
            }

            // 條件滿足，執(zhí)行任務(wù)
            System.out.println("Condition met, task is executing.");

            // 假設(shè)任務(wù)完成后需要重置條件
            ready = false;
        } finally {
            lock.unlock(); // 無論如何，最后都要釋放鎖
        }
    }

    // 觸發(fā)條件的方法
    public void triggerCondition() {
        lock.lock(); // 獲取鎖
        try {
            ready = true; // 設(shè)置條件為true
            condition.signalAll(); // 喚醒所有等待該條件的線程
        } finally {
            lock.unlock(); // 釋放鎖
        }
    }

    public static void main(String[] args) {
        ConditionExample example = new ConditionExample();

        // 創(chuàng)建并啟動線程
        Thread thread = new Thread(() -> {
            try {
                example.task();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        thread.start();

        // 主線程等待一會兒，然后觸發(fā)條件
        try {
            Thread.sleep(1000); // 等待一秒，模擬其他操作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        example.triggerCondition(); // 觸發(fā)條件，喚醒等待的線程
    }
}

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    // 創(chuàng)建一個Semaphore對象，設(shè)置許可數(shù)量為2
    // 這意味著同時最多只能有兩個線程可以訪問資源
    private final Semaphore semaphore = new Semaphore(2);

    // 模擬的資源訪問方法
    public void accessResource() {
        try {
            // 請求許可
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + " has acquired a permit and is accessing the resource.");

            // 模擬資源訪問的耗時操作
            Thread.sleep(1000);

            // 訪問完成后，釋放許可
            semaphore.release();
            System.out.println(Thread.currentThread().getName() + " has released the permit.");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 保持中斷狀態(tài)
            System.out.println(Thread.currentThread().getName() + " was interrupted while accessing the resource.");
        }
    }

    public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();

        // 創(chuàng)建并啟動多個線程來訪問資源
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                example.accessResource();
            }, "Thread-" + (i + 1)).start();
        }
    }
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchExample {

    public static void main(String[] args) throws InterruptedException {
        // 創(chuàng)建一個CountDownLatch實例，設(shè)置計數(shù)器的初始值為2
        // 這意味著我們需要等待兩個任務(wù)完成
        CountDownLatch latch = new CountDownLatch(2);

        // 創(chuàng)建一個線程池來執(zhí)行任務(wù)
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 提交第一個任務(wù)
        executor.submit(() -> {
            try {
                // 模擬任務(wù)執(zhí)行
                System.out.println("Task 1 is running");
                Thread.sleep(1000); // 假設(shè)任務(wù)需要1秒來完成
                System.out.println("Task 1 is done");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                // 任務(wù)完成后，計數(shù)器的值減1
                latch.countDown();
            }
        });

        // 提交第二個任務(wù)
        executor.submit(() -> {
            try {
                // 模擬任務(wù)執(zhí)行
                System.out.println("Task 2 is running");
                Thread.sleep(2000); // 假設(shè)這個任務(wù)需要2秒來完成
                System.out.println("Task 2 is done");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                // 任務(wù)完成后，計數(shù)器的值減1
                latch.countDown();
            }
        });

        // 等待直到所有任務(wù)完成
        latch.await(); // 這會阻塞當前線程，直到計數(shù)器的值變?yōu)?

        // 關(guān)閉線程池
        executor.shutdown();

        // 所有任務(wù)都已完成，繼續(xù)執(zhí)行后續(xù)操作
        System.out.println("All tasks are completed.");
    }
}

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {

    // 創(chuàng)建一個CyclicBarrier對象，設(shè)置屏障點需要等待的線程數(shù)量為3
    // 第二個參數(shù)是一個Runnable對象，它是當所有線程都到達屏障點時會執(zhí)行的任務(wù)（可選）
    private final CyclicBarrier barrier = new CyclicBarrier(3, () -> {
        System.out.println("All threads have reached the barrier. Barrier is now broken.");
    });

    public void task() {
        // 模擬任務(wù)執(zhí)行前的準備工作
        try {
            // 假設(shè)每個線程都需要一些時間來準備
            Thread.sleep((long) (Math.random() * 1000));
            System.out.println(Thread.currentThread().getName() + " is ready.");

            // 等待直到所有線程都到達屏障點
            barrier.await();

            // 所有線程都到達屏障點后，繼續(xù)執(zhí)行后續(xù)任務(wù)
            System.out.println(Thread.currentThread().getName() + " is continuing after the barrier.");
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        CyclicBarrierExample example = new CyclicBarrierExample();

        // 創(chuàng)建并啟動三個線程來執(zhí)行任務(wù)
        for (int i = 1; i <= 3; i++) {
            new Thread(() -> {
                example.task();
            }, "Thread-" + i).start();
        }
    }
}