简化Java多线程问题：同步和异步示例

原创快来打我* 2024-09-29 08:09 80阅读 0赞

在Java中，多线程主要涉及到两种同步机制：同步(Blocking)和异步(Anonymous)。

1. 同步(Blocking)

这种情况下，一个线程需要等待另一个线程完成操作后才能继续执行。这里有一个典型的同步示例：

```java
public class BlockingExample {
    private int count = 0;

public synchronized void increment() {
        count++;
        notifyAll(); // 唤醒所有等待的线程
    }

public synchronized int getCount() {
        while (count == 0) { // 如果计数为0，则一直等待
            try:
                wait();
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return count;
    }

public static void main(String[] args) {
        BlockingExample example = new BlockingExample();

// 创建两个线程，分别尝试增加和获取计数
        Thread incrementThread = new Thread(() -> {
            example.increment();
        }));
        Thread getCountThread = new Thread(() -> {
            System.out.println("Count: " + example.getCount());
        }));

// 启动这两个线程
        incrementThread.start();
        getCountThread.start();

// 等待所有线程执行完毕
        while (!incrementThread.isJoinable() || !getCountThread.isJoinable())) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

// 最后，检查计数是否正确
        System.out.println("Final Count: " + example.getCount()));
    }
}
```

在这个示例中，`increment()`方法是一个同步方法，它会阻塞调用它的线程，直到另一个线程调用了`notifyAll()`来唤醒所有等待的线程。

2. 异步(Anonymous)

这种情况下，线程在执行过程中不会阻塞。例如，使用`Future`或者`CompletableFuture`来处理异步任务：

```java
import java.util.concurrent.*;

public class AsynchronousExample {
    private int count = 0;

public void incrementAsync() {
        Future<Integer> future = CompletableFuture.supply(() -> {
            // 这里是实际的异步操作，例如网络请求等
            // 注意：这里没有阻塞，你可以去做其他事情

// 模拟异步操作成功返回值
            return 1;
        })) .then((result) -> count += result);

// 等待异步任务完成
        try {
            future.get(); // 获取结果
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

public void getCountAsync() {
        Future<Integer> future = CompletableFuture.supply(() -> {
            // 这里是实际的异步操作，例如网络请求等

// 模拟异步操作成功返回值
            return count;
        })) .then((result) -> System.out.println("Count: " + result));

// 等待异步任务完成
        try {
            future.get(); // 获取结果
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

public static void main(String[] args) {
        AsynchronousExample example = new AsynchronousExample();

// 同步方式的示例，这里只是为了对比异步操作的效果
        example.increment(); // 调用`increment()`方法，同步执行

// 异步方式的示例，这里也只是一个简单的模拟
        example.incrementAsync(); // 调用`incrementAsync()`方法，开始异步执行

// 等待异步任务完成
        try {
            Thread.sleep(2000); // 为了模拟异步操作需要的时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

// 输出最终的计数结果
        example.getCountAsync().join(); // 调用`getCountAsync().join()`方法，获取并输出最终的计数结果
    }
}
```

在这个示例中，我们创建了一个类，它有两个方法：`incrementAsync()`和`getCountAsync()`。前者是一个异步操作，后者则是等待异步任务完成后再执行的操作。

最后，在`main`方法中，我们模拟了异步操作需要的时间，然后获取并输出最终的计数结果。