import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3); // 初始化信號量，允許同時訪問的線程數(shù)量為3

        // 創(chuàng)建多個線程來模擬訪問臨界區(qū)資源
        for (int i = 1; i <= 5; i++) {
            int threadId = i;
            Thread thread = new Thread(() -> {
                try {
                    semaphore.acquire(); // 獲取許可證，如果沒有許可證則阻塞
                    System.out.println("Thread " + threadId + " acquired a permit and is accessing the resource.");
                    Thread.sleep(2000); // 模擬訪問臨界區(qū)資源的耗時操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); // 釋放許可證
                    System.out.println("Thread " + threadId + " released the permit.");
                }
            });
            thread.start();
        }
    }
}

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) {
        int numberOfTasks = 3;
        CountDownLatch latch = new CountDownLatch(numberOfTasks);

        // 創(chuàng)建多個線程來模擬完成任務(wù)
        for (int i = 1; i <= numberOfTasks; i++) {
            int taskId = i;
            Thread thread = new Thread(() -> {
                try {
                    System.out.println("Task " + taskId + " is executing...");
                    Thread.sleep(2000); // 模擬任務(wù)執(zhí)行耗時
                    System.out.println("Task " + taskId + " is completed.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown(); // 完成任務(wù)后減少計數(shù)
                }
            });
            thread.start();
        }

        try {
            System.out.println("Main thread is waiting for tasks to complete...");
            latch.await(); // 等待所有任務(wù)完成
            System.out.println("All tasks are completed. Main thread continues.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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

public class CyclicBarrierExample {
    public static void main(String[] args) {
        int numberOfThreads = 3;
        Runnable barrierAction = () -> System.out.println("All threads reached the barrier!");

        CyclicBarrier barrier = new CyclicBarrier(numberOfThreads, barrierAction);

        // 創(chuàng)建多個線程來模擬并行執(zhí)行任務(wù)
        for (int i = 1; i <= numberOfThreads; i++) {
            int threadId = i;
            Thread thread = new Thread(() -> {
                try {
                    System.out.println("Thread " + threadId + " is performing its task.");
                    Thread.sleep(2000); // 模擬任務(wù)執(zhí)行耗時
                    System.out.println("Thread " + threadId + " has reached the barrier.");
                    barrier.await(); // 等待其他線程達(dá)到柵欄點
                    System.out.println("Thread " + threadId + " continues after the barrier.");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
            thread.start();
        }
    }
}

package com.lf.java.basic.concurrent;

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

public class MultipleCyclicBarrierExample {
    public static void main(String[] args) {
        int numberOfThreads = 3;
        int numberOfRounds = 3;
        Runnable barrierAction = () -> System.out.println("All threads reached the barrier!");

        for (int round = 1; round <= numberOfRounds; round++) {
            CyclicBarrier barrier = new CyclicBarrier(numberOfThreads, barrierAction);

            System.out.println("Round " + round + ": Starting tasks");

            // 創(chuàng)建多個線程來模擬并行執(zhí)行任務(wù)
            for (int i = 1; i <= numberOfThreads; i++) {
                int threadId = i;
                int finalRound = round;
                Thread thread = new Thread(() -> {
                    try {
                        System.out.println("Thread " + threadId + " is performing its task for Round " + finalRound);
                        Thread.sleep(2000); // 模擬任務(wù)執(zhí)行耗時
                        System.out.println("Thread " + threadId + " has reached the barrier for Round " + finalRound);
                        barrier.await(); // 等待其他線程達(dá)到柵欄點
                        System.out.println("Thread " + threadId + " continues after the barrier for Round " + finalRound);
                    } catch (InterruptedException | BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                });
                thread.start();
            }

            // 等待所有線程完成當(dāng)前輪次的任務(wù)
            try {
                Thread.sleep(3000); // 等待一段時間以觀察效果
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Round " + round + ": All tasks completed\n");

            // 讓當(dāng)前輪次的所有線程都離開柵欄點，以便重新使用
            barrier.reset();
        }
    }
}

import java.util.concurrent.Phaser;

public class PhaserExample {
    public static void main(String[] args) {
        int numberOfThreads = 3;
        int numberOfPhases = 3;

        Phaser phaser = new Phaser(numberOfThreads) {
            @Override
            protected boolean onAdvance(int phase, int registeredParties) {
                System.out.println("Phase " + phase + " completed.");
                return phase == numberOfPhases - 1 || registeredParties == 0;
            }
        };

        // 創(chuàng)建多個線程來模擬并行執(zhí)行任務(wù)
        for (int i = 0; i < numberOfThreads; i++) {
            int threadId = i;
            Thread thread = new Thread(() -> {
                for (int phase = 0; phase < numberOfPhases; phase++) {
                    System.out.println("Thread " + threadId + " is in Phase " + phase);
                    phaser.arriveAndAwaitAdvance(); // 等待其他線程到達(dá)當(dāng)前階段
                }
            });
            thread.start();
        }
    }
}

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

public class ReentrantLockExample {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        
        // 創(chuàng)建多個線程來模擬使用鎖
        for (int i = 1; i <= 5; i++) {
            int threadId = i;
            Thread thread = new Thread(() -> {
                try {
                    lock.lock(); // 獲取鎖
                    System.out.println("Thread " + threadId + " acquired the lock.");
                    Thread.sleep(2000); // 模擬臨界區(qū)操作耗時
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock(); // 釋放鎖
                    System.out.println("Thread " + threadId + " released the lock.");
                }
            });
            thread.start();
        }
    }
}

package com.lf.java.basic.concurrent;

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

public class InterruptibleLockExample {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();

        // 創(chuàng)建線程嘗試獲取鎖
        Thread thread = new Thread(() -> {
            try {
                lock.lockInterruptibly(); // 可中斷獲取鎖
                System.out.println("Thread acquired the lock.");
                Thread.sleep(5000); // 模擬臨界區(qū)操作耗時
            } catch (InterruptedException e) {
                //中斷喚醒線程
                System.out.println("Thread interrupted while waiting for the lock.");
            } finally {
                if (lock.isHeldByCurrentThread()) {
                    lock.unlock(); // 釋放鎖
                    System.out.println("Thread released the lock.");
                }
            }
        });

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

        // 主線程等待一段時間后嘗試中斷線程
        try {
            Thread.sleep(2000);
            System.out.println("Thread interrupt before");
            thread.interrupt(); // 中斷線程的等待
            System.out.println("Thread interrupt after");
        } catch (InterruptedException e) {
            System.out.println("InterruptedException catch");
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    public static void main(String[] args) {
        ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        
        // 創(chuàng)建多個讀線程
        for (int i = 1; i <= 5; i++) {
            int threadId = i;
            Thread thread = new Thread(() -> {
                readWriteLock.readLock().lock(); // 獲取讀鎖
                try {
                    System.out.println("Thread " + threadId + " is reading.");
                    Thread.sleep(2000); // 模擬讀取操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    readWriteLock.readLock().unlock(); // 釋放讀鎖
                }
            });
            thread.start();
        }

        // 創(chuàng)建一個寫線程
        Thread writeThread = new Thread(() -> {
            readWriteLock.writeLock().lock(); // 獲取寫鎖
            try {
                System.out.println("Write thread is writing.");
                Thread.sleep(2000); // 模擬寫入操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                readWriteLock.writeLock().unlock(); // 釋放寫鎖
            }
        });
        writeThread.start();
    }
}

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

public class ConditionExample {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        // 創(chuàng)建一個等待線程
        Thread waitingThread = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Waiting thread is waiting...");
                condition.await(); // 等待條件滿足
                System.out.println("Waiting thread is awake.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

        // 創(chuàng)建一個喚醒線程
        Thread signalingThread = new Thread(() -> {
            lock.lock();
            try {
                Thread.sleep(2000); // 模擬等待一段時間
                System.out.println("Signaling thread is awake.");
                condition.signal(); // 喚醒等待線程
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

        // 啟動線程
        waitingThread.start();
        signalingThread.start();
    }
}

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

public class BlockingQueueWithCondition<T> {
    private final Queue<T> queue = new LinkedList<>();
    private final int capacity;

    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    public BlockingQueueWithCondition(int capacity) {
        this.capacity = capacity;
    }

    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity) {
                notFull.await();
            }
            queue.offer(item);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            T item = queue.poll();
            notFull.signal();
            return item;
        } finally {
            lock.unlock();
        }
    }

    public int size() {
        lock.lock();
        try {
            return queue.size();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        BlockingQueueWithCondition<Integer> queue = new BlockingQueueWithCondition<>(5);

        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    int item = queue.take();
                    System.out.println("Consumed: " + item);
                    Thread.sleep(1500);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);

        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    int item = queue.take();
                    System.out.println("Consumed: " + item);
                    Thread.sleep(1500);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

public class BlockingDequeExample {
    public static void main(String[] args) {
        BlockingDeque<Integer> deque = new LinkedBlockingDeque<>(5);

        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    deque.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    int item = deque.take();
                    System.out.println("Consumed: " + item);
                    Thread.sleep(1500);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

import java.util.concurrent.locks.LockSupport;

public class LockSupportExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is going to be parked.");
            LockSupport.park(); // 阻塞當(dāng)前線程
            System.out.println("Thread is unparked.");
        });

        thread.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main thread is unparking the parked thread.");
        LockSupport.unpark(thread); // 喚醒被阻塞的線程
    }
}

import java.util.concurrent.Exchanger;

public class ExchangerExample {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();

        // 創(chuàng)建一個線程來發(fā)送數(shù)據(jù)
        Thread senderThread = new Thread(() -> {
            try {
                String dataToSend = "Hello from Sender";
                System.out.println("Sender is sending: " + dataToSend);
                exchanger.exchange(dataToSend); // 發(fā)送數(shù)據(jù)并等待接收數(shù)據(jù)
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 創(chuàng)建一個線程來接收數(shù)據(jù)
        Thread receiverThread = new Thread(() -> {
            try {
                String receivedData = exchanger.exchange(null); // 等待接收數(shù)據(jù)并發(fā)送數(shù)據(jù)
                System.out.println("Receiver received: " + receivedData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 啟動線程
        senderThread.start();
        receiverThread.start();
    }
}