Java中线程同步控制关键字使用实例

原创淩亂°似流年 2024-11-14 04:21 45阅读 0赞

在Java中，线程同步控制是多线程编程中非常重要的一部分，它确保了多个线程在访问共享资源时的一致性和线程安全。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`变量的访问是线程安全的。

####修饰代码块```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;
 }
 }
}
```在这个例子中，我们使用一个对象`lock`作为锁，来同步代码块。

###2. Lock接口和ReentrantLock类`java.util.concurrent.locks.Lock`接口和`java.util.concurrent.locks.ReentrantLock`类提供了比`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();
 }
 }
}
```在这个例子中，我们使用`ReentrantLock`来控制对`count`变量的访问。

###3. volatile关键字`volatile`关键字用于修饰变量，确保变量的修改对所有线程立即可见，但它不保证复合操作的原子性。

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

public void increment() {
 count++;
 }

public int getCount() {
 return count;
 }
}
```在这个例子中，`count`变量被声明为`volatile`，确保每次读取`count`都是最新的值。

###4. atomic包`java.util.concurrent.atomic`包提供了一组原子类，用于无锁的线程安全编程。

```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();
 }
}
```在这个例子中，我们使用`AtomicInteger`来确保`increment`和`getCount`操作的原子性。

这些是Java中线程同步控制的一些基本关键字和机制的使用实例。在实际应用中，选择哪种同步机制取决于具体的应用场景和性能要求。

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