遇到的Java并发控制不当问题示例

原创喜欢ヅ旅行 2024-11-08 20:27 9阅读 0赞

Java并发控制不当可能会导致多种问题，包括但不限于数据不一致、死锁、竞态条件等。以下是一些常见的Java并发控制不当的示例：

###1.竞态条件（Race Condition）
竞态条件发生在多个线程访问共享数据时，最终结果依赖于线程执行的顺序。如果这个顺序不可预测，就可能产生不一致的结果。

**示例代码：**
```javapublic class Counter {
 private int count =0;

public void increment() {
 count++; //非原子操作 }

public int getCount() {
 return count;
 }
}
```
在这个例子中，`increment` 方法不是原子的，如果多个线程同时调用这个方法，`count` 的值可能不会正确增加。

###2.死锁（Deadlock）
死锁发生在两个或多个线程在等待对方释放资源，导致它们永远阻塞。

**示例代码：**
```javapublic class DeadlockExample {
 private final Object lock1 = new Object();
 private final Object lock2 = new Object();

public void method1() {
 synchronized (lock1) {
 try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock2) {
 System.out.println("Lock2 acquired");
 }
 }
 }

public void method2() {
 synchronized (lock2) {
 try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock1) {
 System.out.println("Lock1 acquired");
 }
 }
 }
}
```
如果两个线程分别调用 `method1` 和 `method2`，它们可能会互相等待对方释放锁，导致死锁。

###3.活锁（Livelock）
活锁是指线程在尝试获取资源时不断重试，但总是因为其他线程也在做同样的事情而失败，导致它们不断循环。

**示例代码：**
```javapublic class LivelockExample {
 public void doWork() {
 while (true) {
if (shouldDoWork()) {
 doActualWork();
 break;
 }
//等待一段时间，然后重试 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 }
 }

private boolean shouldDoWork() {
//检查是否可以工作，但总是返回false return false;
 }

private void doActualWork() {
// 实际工作 }
}
```
在这个例子中，`doWork` 方法会不断检查是否可以工作，但由于 `shouldDoWork`总是返回 `false`，它将不断重试，导致活锁。

###4.资源泄露（Resource Leak）
资源泄露发生在线程持有资源（如文件句柄、数据库连接等）后未能正确释放，导致资源耗尽。

**示例代码：**
```javapublic class ResourceLeakExample {
 public void doSomething() {
Connection connection = null;
 try {
 connection = dataSource.getConnection();
// 使用连接} catch (SQLException e) {
e.printStackTrace();
} finally {
//忘记关闭连接 }
 }
}
```
在这个例子中，如果 `finally`块中没有关闭数据库连接，那么每次调用 `doSomething` 方法都可能导致一个未关闭的连接，最终导致资源泄露。

解决这些问题通常需要使用同步机制（如 `synchronized` 关键字、`ReentrantLock`、`Semaphore`等），或者使用并发集合（如 `ConcurrentHashMap`），以及合理地管理资源。