Java多线程：竞态条件和死锁实例

原创淡淡的烟草味﹌ 2024-11-01 22:24 18阅读 0赞

在Java中，多线程编程是常见的，但同时也容易引入竞态条件和死锁等问题。下面我将分别给出竞态条件和死锁的实例。

###竞态条件实例竞态条件是指多个线程在访问共享资源时，由于执行顺序的不确定性，导致程序结果不可预测的现象。

```javaclass Counter {
 private int count =0;

public void increment() {
 count++; //非原子操作，包含读取、增加、写入三个步骤 }

public int getCount() {
 return count;
 }
}

public class RaceConditionExample {
 public static void main(String[] args) {
Counter counter = new Counter();

Thread thread1 = new Thread(() -> {
 for (int i =0; i <1000; i++) {
 counter.increment();
 }
 });

Thread thread2 = new Thread(() -> {
 for (int i =0; i <1000; i++) {
 counter.increment();
 }
 });

thread1.start();
 thread2.start();

try {
 thread1.join();
 thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
 }

System.out.println("Expected count:2000, Actual count: " + counter.getCount());
 }
}
```在这个例子中，`Counter` 类的 `increment` 方法是非原子的，当两个线程同时执行时，可能会出现竞态条件，导致 `count` 的最终值小于2000。

###死锁实例死锁是指两个或多个线程在等待对方释放资源，导致程序无法继续执行的状态。

```javaclass Resource {
 private final int id;

public Resource(int id) {
 this.id = id;
 }

@Override public String toString() {
 return "Resource{" + "id=" + id + '}';
 }
}

public class DeadlockExample {
 private static final Object resource1 = new Object();
 private static final Object resource2 = new Object();

public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
 synchronized (resource1) {
 System.out.println("Thread1: Locked resource1");
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (resource2) {
 System.out.println("Thread1: Locked resource2");
 }
 }
 });

Thread thread2 = new Thread(() -> {
 synchronized (resource2) {
 System.out.println("Thread2: Locked resource2");
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (resource1) {
 System.out.println("Thread2: Locked resource1");
 }
 }
 });

thread1.start();
 thread2.start();
 }
}
```在这个例子中，`thread1` 和 `thread2` 分别尝试锁定 `resource1` 和 `resource2`。由于它们尝试以不同的顺序锁定资源，导致死锁。

为了避免竞态条件和死锁，可以采取以下措施：

1. 使用同步机制（如 `synchronized` 关键字）确保原子性操作。
2. 使用 `Lock`接口和 `ReentrantLock` 类提供更灵活的锁定机制。
3. 使用 `volatile` 关键字确保变量的可见性。
4. 使用 `Atomic` 类（如 `AtomicInteger`）提供原子操作。
5.避免嵌套锁定，确保所有线程以相同的顺序锁定资源。

希望这些实例和建议能帮助你理解竞态条件和死锁，并在实际编程中避免这些问题。