Java多线程并发编程中的锁问题案例

原创不念不忘少年蓝@ 2024-11-01 07:09 41阅读 0赞

Java多线程并发编程中，锁（Lock）是用来控制多个线程对共享资源访问的机制，以保证数据的一致性和完整性。以下是一些常见的锁问题案例：

###1.死锁（Deadlock）
死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种僵局，导致这些线程无法继续执行。

**案例：**
```javapublic class DeadlockExample {
 private static final Object lock1 = new Object();
 private static final Object lock2 = new Object();

public static void main(String[] args) {
 new Thread(() -> {
 synchronized (lock1) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock2) {
 System.out.println("Thread1 acquired both locks");
 }
 }
 }).start();

new Thread(() -> {
 synchronized (lock2) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock1) {
 System.out.println("Thread2 acquired both locks");
 }
 }
 }).start();
 }
}
```
在这个例子中，两个线程分别尝试获取两个锁，但顺序不同，导致死锁。

###2.活锁（Livelock）
活锁是指多个线程在尝试获取资源时，由于某种条件总是不满足，导致线程不断重试，但始终无法继续执行。

**案例：**
```javapublic class LivelockExample {
 public static void main(String[] args) {
Thread t1 = new Thread(() -> {
 while (true) {
if (Math.random() >0.5) {
 System.out.println("Thread1 is running");
 break;
 }
 }
 });

Thread t2 = new Thread(() -> {
 while (true) {
if (Math.random() >0.5) {
 System.out.println("Thread2 is running");
 break;
 }
 }
 });

t1.start();
t2.start();
 }
}
```
在这个例子中，两个线程通过随机数决定是否运行，如果随机数小于0.5，则重试，导致活锁。

###3.资源竞争（Race Condition）
资源竞争是指多个线程同时访问同一资源，导致数据不一致的问题。

**案例：**
```javapublic class RaceConditionExample {
 private static int count =0;

public static void main(String[] args) {
Thread t1 = new Thread(() -> {
 for (int i =0; i <1000; i++) {
 count++;
 }
 });

Thread t2 = new Thread(() -> {
 for (int i =0; i <1000; i++) {
 count++;
 }
 });

t1.start();
t2.start();

try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
 }

System.out.println("Final count: " + count);
 }
}
```
在这个例子中，两个线程同时对`count`变量进行自增操作，由于没有同步机制，可能导致最终的`count`值小于2000。

###4.锁粗化（Lock Coarsening）
锁粗化是指将多个细粒度锁合并为一个粗粒度锁，以减少锁的开销。

**案例：**
```javapublic class LockCoarseningExample {
 private final List<String> list = new ArrayList<>();

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

public void remove(String item) {
 synchronized (list) {
 list.remove(item);
 }
 }
}
```
在这个例子中，`add`和`remove`方法都对`list`进行同步，可以考虑将这两个方法合并为一个方法，并使用一个粗粒度锁。

###5.锁消除（Lock Elimination）
锁消除是指编译器或运行时自动移除不必要的锁，以提高性能。

**案例：**
```javapublic class LockEliminationExample {
 private int count =0;

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

public void read() {
int temp = count; //编译器可能会消除这个锁 }
}
```
在这个例子中，`read`方法只是读取`count`的值，编译器可能会消除这个锁，因为`count`的值不会被修改。

以上是一些常见的锁问题案例，实际开发中需要根据具体情况选择合适的锁机制和策略。