在多线程编程中，线程同步是一个非常重要的概念。当多个线程需要访问共享资源时，如果没有适当的同步机制，可能会导致数据不一致或程序崩溃。以下是五种常见的线程同步方式：
1. 使用锁（Locks）
锁是最基本的同步机制之一。通过锁定和解锁共享资源，确保同一时间只有一个线程可以访问该资源。Java中的`ReentrantLock`就是一个典型的例子。使用锁时需要注意避免死锁问题。
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private int count = 0;
private final Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
return count;
}
}
```
2. 使用同步块（Synchronized Blocks）
Java提供了`synchronized`关键字来实现同步。可以通过将共享资源的访问放在`synchronized`块中，确保在同一时刻只有一个线程能够执行该代码块。
```java
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
```
3. 使用信号量（Semaphores）
信号量是一种更高级的同步工具，它允许多个线程同时访问某个资源。通过设置信号量的许可数，可以控制同时访问资源的线程数量。
```java
import java.util.concurrent.Semaphore;
public class Pool {
private final Semaphore semaphore;
public Pool(int size) {
this.semaphore = new Semaphore(size);
}
public void useResource() {
try {
semaphore.acquire();
// 使用资源
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
semaphore.release();
}
}
}
```
4. 使用CountDownLatch
`CountDownLatch`允许一个或多个线程等待其他线程完成操作。它通过计数器来管理线程的同步。
```java
import java.util.concurrent.CountDownLatch;
public class TaskRunner {
private final CountDownLatch latch;
public TaskRunner(int taskCount) {
this.latch = new CountDownLatch(taskCount);
}
public void startTask() {
new Thread(() -> {
// 执行任务
latch.countDown();
}).start();
}
public void awaitTasksCompletion() throws InterruptedException {
latch.await();
}
}
```
5. 使用volatile关键字
`volatile`关键字用于确保变量的可见性，即一旦一个线程修改了`volatile`变量的值，这个新值会立即被其他线程看到。虽然它不能替代锁，但在某些情况下可以用来简化同步。
```java
public class SharedData {
private volatile boolean ready = false;
public void setReady() {
ready = true;
}
public boolean isReady() {
return ready;
}
}
```
以上是五种常见的线程同步方式。每种方式都有其适用场景，选择合适的同步机制可以提高程序的性能和稳定性。在实际开发中，应根据具体需求选择最合适的同步方案。
