并发控制Java：线程安全的代码实例与理解

原创淡淡的烟草味﹌ 2024-11-08 20:48 9阅读 0赞

在Java中，编写线程安全的代码是一个重要的议题，因为多线程环境下，共享资源的访问可能会导致数据不一致、竞态条件等问题。以下是一些实现线程安全的方法和代码实例：

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

```javapublic class Counter {
 private int count =0;

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

public synchronized int getCount() {
 return count;
 }
}
```在这个例子中，`increment`和`getCount`方法都被`synchronized`修饰，确保了对`count`变量的访问是线程安全的。

###2. 使用`ReentrantLock`

`ReentrantLock`是一个可重入的互斥锁，提供了与`synchronized`关键字类似的功能，但是提供了更多的灵活性。

```javaimport java.util.concurrent.locks.ReentrantLock;

public class Counter {
 private final ReentrantLock lock = new ReentrantLock();
 private int count =0;

public void increment() {
lock.lock();
 try {
 count++;
} finally {
lock.unlock();
 }
 }

public int getCount() {
lock.lock();
 try {
 return count;
} finally {
lock.unlock();
 }
 }
}
```###3. 使用`volatile`关键字`volatile`关键字可以确保变量的读写操作对所有线程都是可见的，但是它不能保证复合操作的原子性。

```javapublic class Flag {
 private volatile boolean flag = false;

public void setFlag() {
 flag = true;
 }

public boolean isFlagSet() {
 return flag;
 }
}
```###4. 使用`Atomic`类`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();
 }
}
```###5. 使用`Concurrent`集合`java.util.concurrent`包提供了线程安全的集合类，如`ConcurrentHashMap`、`CopyOnWriteArrayList`等。

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

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

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

public String get(Integer key) {
 return map.get(key);
 }
}
```理解线程安全的代码需要掌握Java内存模型（JMM）和happens-before原则，这些概念帮助我们理解在多线程环境下，如何确保操作的可见性和有序性。正确使用上述工具和方法，可以有效地编写出线程安全的代码。