Java并发编程常见问题实例

原创比眉伴天荒 2024-09-13 00:39 64阅读 0赞

在Java并发编程中，常见的问题和实例包括：

1. **死锁**：多个线程等待对方释放资源导致的循环等待。例如：

```java
// 死锁代码
Lock lock1 = new ReentrantLock();
Lock lock2 = new ReentrantLock();

Thread t1 = new Thread(() -> {
    lock1.lock(); // 线程1获取锁1
    try {
        System.out.println("t1正在等待..."); // 释放锁1
        lock2.lock(); // 等待锁2
        System.out.println("t1成功获得了所有资源!"); // 使用锁2
        lock2.unlock(); // 释放锁2
        lock1.unlock(); // 释放锁1
    } catch (Exception e) {
        e.printStackTrace();
    }
}));
Thread t2 = new Thread(() -> {
    lock2.lock(); // 线程2获取锁2
    try {
        System.out.println("t2正在等待..."); // 释放锁2
        lock1.lock(); // 等待锁1
        System.out.println("t2成功获得了所有资源!"); // 使用锁1
        lock1.unlock(); // 释放锁1
        lock2.unlock(); // 释放锁2
    } catch (Exception e) {
        e.printStackTrace();
    }
}));
t1.start();
t2.start();
```

2. **线程同步**：如何保证多个线程同时执行特定任务时不会出现数据不一致的问题。例如使用synchronized关键字：

```java
public class Counter {
    private int count;

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

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new IllegalArgumentException("Counter is already at zero!");
        }
    }

public synchronized int getCount() {
        return count;
    }
}
```

3. **线程池**：如何高效地管理多个线程，避免频繁创建和销毁线程。使用Java的`ThreadPoolExecutor`就是一个典型例子：

```java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(10);

// 提交任务到线程池
        for (int i = 0; i < 50; i++) {
            Runnable task = () -> {
                System.out.println("Task " + i + " is being executed by thread: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            executor.submit(task);
        }

// 关闭线程池
        executor.shutdown();

// 检查线程池是否已关闭，且所有任务已完成
        while (!executor.isTerminated()) {
            System.out.println("Executor is still running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

System.out.println("All tasks have completed. Executor has been shut down.");

}
}
```

以上是Java并发编程中常见的问题和实例。