在Java中处理并发问题的实践示例

原创 - 日理万妓 2024-11-30 19:00 0阅读 0赞

在Java中，处理并发问题主要是通过线程、同步机制（如synchronized关键字）和并发工具类（如ExecutorService）来实现。

以下是一些实践示例：

1. **创建线程**：
```java
// 创建一个Thread对象
Thread thread = new Thread(() -> {
    // 线程任务
    System.out.println("Thread task executed");
});
// 启动线程
thread.start();
```

2. **使用synchronized关键字同步代码块**：
```java
class Counter {
    private int count;

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

public synchronized int decrementIfPositive() {
        if (count > 0) {
            count--;
            return count;
        }
        return 0;
    }
}

// 使用示例
Counter counter = new Counter();
counter.increment(); // 线程安全
int decrementResult = counter.decrementIfPositive();
System.out.println("Decrement result: " + decrementResult);
```

3. **使用ExecutorService和Runnable**：
```java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class LongRunningTask implements Runnable {
    private int count;

public LongRunningTask(int count) {
        this.count = count;
    }

@Override
    public void run() {
        try {
            for (int i = 0; i < count; i++) {
                System.out.println("Long running task - iteration " + i);
                Thread.sleep(1000); // 模拟长时间运行
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ConcurrentProgrammingExample {
    public static void main(String[] args) {
        int threadCount = 5; // 创建线程的数量

ExecutorService executorService = Executors.newFixedThreadPool(threadCount); // 创建线程池

for (int i = 0; i < threadCount; i++) { // 对每个线程任务
            LongRunningTask longRunningTask = new LongRunningTask(i * 10)); // 创建LongRunningTask对象并传入初始值

executorService.submit(longRunningTask); // 提交任务到线程池
        }

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

try {
            while (!executorService.isTerminated())) {
                System.out.println("ExecutorService still running");
                Thread.sleep(500); // 暂停打印，模拟处理其他任务
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("All threads have completed their tasks.");
    }
}
```

这个示例展示了如何使用线程池（ExecutorService）来异步执行多个耗时的任务。