Java多线程同步问题：线程安全的代码实例

原创悠悠 2024-11-11 11:36 10阅读 0赞

在Java中，多线程同步是一个重要的概念，它确保了当多个线程访问共享资源时，这些资源的一致性和完整性。以下是一些线程安全的代码实例，它们展示了如何使用不同的同步机制来保护共享资源。

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

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

//同步方法 public synchronized void increment() {
 count++;
 }

public synchronized int getCount() {
 return 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. 使用`AtomicInteger`

`AtomicInteger`是一个提供原子操作的整数类，适用于简单的计数器场景。

```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. 使用`volatile`关键字`volatile`关键字确保变量的读写操作对所有线程都是可见的，但它不保证复合操作的原子性。

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

public void increment() {
 count++;
 }

public int getCount() {
 return count;
 }
}
```###5. 使用`Collections.synchronizedList`等对于集合类，可以使用`Collections`类提供的同步包装器来创建线程安全的集合。

```javaimport java.util.Collections;
import java.util.List;
import java.util.ArrayList;

public class SafeList {
 private List<String> list = Collections.synchronizedList(new ArrayList<>());

public void add(String item) {
 list.add(item);
 }

public List<String> getList() {
 return new ArrayList<>(list); // 返回列表的拷贝以保持封装性 }
}
```这些是一些基本的线程安全代码实例。在实际应用中，选择哪种同步机制取决于具体的应用场景和性能要求。

还没有评论，来说两句吧...