书接上文
三、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();
}
}
未完待续