Java并发编程：Locks和Conditionals实例

原创不念不忘少年蓝@ 2024-11-27 12:09 25阅读 0赞

在Java并发编程中，锁（Lock）和条件变量（Condition）是两种重要的同步工具，主要用于控制多个线程的执行顺序。

1. Lock (锁)：
- `ReentrantLock`：可重入的锁，支持公平和非公平两种模式。
   - 公平模式下，等待锁的时间较长的线程优先获得锁。
   - 非公平模式下，没有特定的获取锁顺序，性能通常更好。

- 示例代码：
```java
import java.util.concurrent.locks.ReentrantLock;

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

public void acquire() {
        try {
            lock.acquire();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 线程中断，恢复控制
            e.printStackTrace();
        }
    }

public void release() {
        try {
            lock.release();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

public static void main(String[] args) {
        LockExample example = new LockExample();
        example.acquire(); // 获取锁
        // 然后执行多线程操作...
        example.release(); // 释放锁
    }
}
```

2. Conditionals (条件变量)：
- `Semaphore`：信号量，用于控制在同一资源上访问的线程数量。
- `CountDownLatch`：倒计时器，用于等待所有线程完成任务后进行特定操作。

- 示例代码：
```java
import java.util.concurrent.*;

public class ConditionalsExample {
    private final CountDownLatch countDownLatch = new CountDownLatch(2);

public void startThreads() throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 starting...");
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 线程中断，恢复控制
                e.printStackTrace();
            }
            System.out.println("Thread 1 completed.");
        }));

Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 starting...");
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 线程中断，恢复控制
                e.printStackTrace();
            }
            System.out.println("Thread 2 completed.");
        }));

thread1.start();
        thread2.start();

// 等待所有线程完成任务...
        countDownLatch.countDown();
    }

public static void main(String[] args) {
        ConditionalsExample example = new ConditionalsExample();
        example.startThreads(); // 启动线程
    }
}
```

以上代码展示了如何使用Lock（锁）和Conditionals（条件变量）来控制多线程的执行。