同步工具类Lock、Semaphore、CyclicBarrier在Java中应用示例

原创系统管理员 2024-11-23 05:33 12阅读 0赞

1. Lock：Lock是一种独占锁，只有一个线程可以获取并持有锁，其他线程需要等待锁释放。示例：

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

public class LockExample {
    private final Lock lock = new ReentrantLock();

public void acquireLock() {
        try {
            lock.acquire();
            System.out.println("Lock acquired by thread.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void releaseLock() {
        try {
            lock.release();
            System.out.println("Lock released by thread.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

public static void main(String[] args) {
        LockExample example = new LockExample();
        Thread t1 = new Thread(() -> example.acquireLock()));
        Thread t2 = new Thread(() -> example.releaseLock()));

t1.start();
        t2.start();

try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

2. Semaphore：Semaphore是一种可以限制并发访问的工具。它初始值为N（N>0）表示最多允许N个线程同时执行。示例：

```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3);

public void acquireSemaphore() throws InterruptedException {
        semaphore.acquire();
        System.out.println("Semaphore acquired by thread.");
    }

public void releaseSemaphore() {
        try {
            semaphore.release();
            System.out.println("Semaphore released by thread.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();
        Thread t1 = new Thread(() -> example.acquireSemaphore()));
        Thread t2 = new Thread(() -> example.releaseSemaphore()));

t1.start();
        t2.start();

try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

3. CyclicBarrier：CyclicBarrier是一个同步工具，它允许多个线程等待一个固定点的到来。当最后一个线程到达该点后，所有线程都会立即获取锁并执行后续操作。示例：

```java
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    private final CyclicBarrier barrier = new CyclicBarrier(2);

public void participate() throws InterruptedException {
        barrier.await();
        System.out.println("Participant reached barrier.");
    }

public static void main(String[] args) {
        CyclicBarrierExample example = new CyclicBarrierExample();
        Thread t1 = new Thread(() -> example.participate()));
        Thread t2 = new Thread(() -> example.participate()));

t1.start();
        t2.start();

try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

注意：以上示例中，线程的执行顺序可能会根据实际操作系统和Java虚拟机环境的不同而有所差异。