Java 中的线程是什么，如何创建和管理线程-中（十二）

书接上文

三、Java 线程的同步

Java 中的线程同步是通过 synchronized 关键字实现的。在多线程环境下，当多个线程同时访问共享资源时，如果不进行同步控制，就会出现数据不一致、死锁等问题。为了保证多个线程之间的安全访问，需要使用 synchronized 关键字来进行同步控制。

synchronized 关键字可以用于方法或者代码块中，用于控制访问共享资源的顺序。当一个线程获取到一个对象的 synchronized 锁时，其他线程只能够等待该线程释放锁后才能继续执行。这种机制称为互斥锁。

在 Java 中，可以使用以下几种方式进行同步控制：

同步代码块

使用 synchronized 关键字修饰代码块，以控制访问共享资源的顺序。例如：

public class Test {
    private int count = 0;

    public void increment() {
        synchronized (this) { // 对象锁
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

同步方法

使用 synchronized 关键字修饰方法，以控制访问共享资源的顺序。例如：

public class Test {
    private int count = 0;

    public synchronized void increment() { // 对象锁
        count++;
    }

    public int getCount() {
        return count;
    }
}

重入锁

重入锁是一种可重复获取的互斥锁，可以避免死锁问题。重入锁需要使用 Lock 接口和 Condition 接口实现。例如：

import java.util.concurrent.locks.*;

public class Test {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
            condition.signalAll(); // 唤醒所有等待线程
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public int getCount() {
        return count;
    }
}

Java 线程的异步

Java 中的异步编程通常使用回调函数、Future 和 CompletableFuture 进行处理。在 Java 8 中，新增了 CompletableFuture 类，提供了更为强大的异步编程支持。

回调函数

回调函数是一种异步编程模式，可以在某个操作完成后自动调用指定的函数。在 Java 中，可以使用回调函数来处理异步任务。例如：

public interface MyCallback {
    void onCompleted(String result);
}

public class MyTask {
    public void run(MyCallback callback) {
        Thread t = new Thread(() -> {
            String result = doTask();
            callback.onCompleted(result);
        });
        t.start();
    }

    private String doTask() { // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "result";
    }
}

public class Test {
    public static void main(String[] args) {
        MyTask task = new MyTask();
        task.run(result -> System.out.println("Result: " + result));
        System.out.println("Task started.");
    }
}

Future

Future 是一个异步编程模型，用于表示一个尚未完成的异步任务，并且可以在之后获取任务的结果。在 Java 中，可以使用 Future 来处理异步任务。例如：

import java.util.concurrent.*;

public class MyTask implements Callable<String> {
    public String call() throws Exception {
        return doTask();
    }

    private String doTask() { // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "result";
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyTask());

可以使用 Future 的 get() 方法来等待任务的完成并获取结果，该方法会阻塞当前线程直到任务完成。例如：

import java.util.concurrent.*;

public class MyTask implements Callable<String> {
    public String call() throws Exception {
        return doTask();
    }

    private String doTask() { // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "result";
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyTask());
        System.out.println("Task submitted.");

        String result = future.get(); // 等待任务完成并获取结果
        System.out.println("Result: " + result);

        executor.shutdown();
    }
}

未完待续