线程同步困惑：Java多线程并发控制示例

原创落日映苍穹つ 2024-11-02 00:57 21阅读 0赞

在Java中，多线程并发控制是一个重要的主题，因为它涉及到如何安全地在多线程环境中共享资源。以下是一些常见的并发控制技术，以及相应的Java代码示例：

###1. synchronized关键字`synchronized`关键字可以用来修饰方法或者代码块，确保同一时间只有一个线程可以执行该段代码。

**修饰方法：**
```javapublic class Counter {
 private int count =0;

public synchronized void increment() {
 count++;
 }

public synchronized int getCount() {
 return count;
 }
}
```**修饰代码块：**
```javapublic class Counter {
 private int count =0;
 private final Object lock = new Object();

public void increment() {
 synchronized (lock) {
 count++;
 }
 }

public int getCount() {
 synchronized (lock) {
 return count;
 }
 }
}
```###2. Lock接口和实现类`java.util.concurrent.locks.Lock`接口提供了比`synchronized`更灵活的锁定机制。

```javaimport 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() {
lock.lock();
 try {
 return count;
} finally {
lock.unlock();
 }
 }
}
```###3.原子变量`java.util.concurrent.atomic`包提供了一组原子类，它们利用CAS（Compare-And-Swap）操作来保证操作的原子性。

```javaimport java.util.concurrent.atomic.AtomicInteger;

public class Counter {
 private AtomicInteger count = new AtomicInteger(0);

public void increment() {
 count.incrementAndGet();
 }

public int getCount() {
 return count.get();
 }
}
```###4.并发集合`java.util.concurrent`包提供了线程安全的集合类，如`ConcurrentHashMap`。

```javaimport java.util.concurrent.ConcurrentHashMap;

public class SharedMap {
 private ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();

public void put(int key, String value) {
map.put(key, value);
 }

public String get(int key) {
 return map.get(key);
 }
}
```###5.线程池使用`java.util.concurrent`包中的`ExecutorService`来管理线程池，可以有效地控制并发线程的数量。

```javaimport java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
 private final ExecutorService executor = Executors.newFixedThreadPool(10);

public void executeTask(Runnable task) {
 executor.execute(task);
 }

public void shutdown() {
 executor.shutdown();
 }
}
```这些是Java中实现线程同步和并发控制的一些基本方法。根据具体的应用场景和需求，你可以选择最适合的方法来保证线程安全。