Java中的同步与异步编程

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们来探讨一下Java中的同步与异步编程。同步和异步是编程中的两个基本概念，理解并掌握它们对编写高效的并发应用程序非常重要。下面我们将通过具体的代码示例详细讲解这两个概念。

一、同步编程

同步编程是一种在同一时间只能执行一个任务的编程方式。线程必须等待前一个线程完成后才能继续执行。以下是一个简单的同步编程示例：

package cn.juwatech.sync;

public class SynchronizedExample {
    private int count = 0;

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

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + example.count);
    }
}

在上述代码中，increment方法使用synchronized关键字进行修饰，确保同一时刻只有一个线程可以执行该方法，从而避免竞态条件。

二、异步编程

异步编程允许在不等待其他任务完成的情况下执行多个任务。Java中的异步编程可以通过多线程、Future、CompletableFuture等方式实现。下面是一个使用CompletableFuture的异步编程示例：

package cn.juwatech.async;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(2000);
                System.out.println("Async task completed!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("Main thread continues...");

        future.join();  // 等待异步任务完成
    }
}

在上述代码中，CompletableFuture.runAsync方法用于在另一个线程中异步执行任务，而主线程则继续执行自己的任务，不会被阻塞。

三、同步与异步结合

在实际应用中，常常需要将同步和异步编程结合使用。以下是一个示例，展示如何在异步任务中使用同步方法：

package cn.juwatech.combined;

import java.util.concurrent.CompletableFuture;

public class CombinedExample {
    private int count = 0;

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

    public void asyncTask() {
        CompletableFuture.runAsync(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
            System.out.println("Async task completed. Count: " + count);
        });
    }

    public static void main(String[] args) {
        CombinedExample example = new CombinedExample();
        example.asyncTask();
        example.asyncTask();

        try {
            Thread.sleep(3000);  // 等待异步任务完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + example.count);
    }
}

在这个示例中，asyncTask方法使用CompletableFuture.runAsync在异步线程中执行increment方法，并确保每次增加操作是同步的。

四、异步与回调

异步编程的一个常见应用是使用回调函数处理异步任务的结果。以下是一个示例，展示如何使用CompletableFuture的回调方法：

package cn.juwatech.async;

import java.util.concurrent.CompletableFuture;

public class CallbackExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Async result";
        });

        future.thenAccept(result -> {
            System.out.println("Received result: " + result);
        });

        System.out.println("Main thread continues...");

        try {
            Thread.sleep(3000);  // 等待异步任务完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，CompletableFuture.supplyAsync方法用于异步计算结果，并通过thenAccept方法注册一个回调函数，当结果计算完成后，该回调函数会被调用。

五、并行处理

异步编程的另一个重要应用是并行处理多个任务。以下是一个示例，展示如何使用CompletableFuture并行执行多个任务，并汇总结果：

package cn.juwatech.parallel;

import java.util.concurrent.CompletableFuture;

public class ParallelExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result 1";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result 2";
        });

        CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(future1, future2);

        combinedFuture.thenRun(() -> {
            try {
                String result1 = future1.get();
                String result2 = future2.get();
                System.out.println("Combined result: " + result1 + ", " + result2);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        System.out.println("Main thread continues...");

        try {
            combinedFuture.join();  // 等待所有异步任务完成
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，两个异步任务并行执行，CompletableFuture.allOf方法用于等待所有任务完成，并通过thenRun方法注册一个回调函数处理所有任务的结果。

著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！