线程系列 4 - synchronized 和线程间的通信

**线程系列4 - synchronized 和线程间的通信**

在前面的文章中，我们已经学习了线程的基本概念、创建线程的方法以及线程的生命周期。然而，在多线程编程中，一个非常重要的问题是如何让不同的线程之间进行通信和同步。

**1. synchronized**

`synchronized` 是 Java 中的一个关键字，它可以用来修饰一个方法或一个代码块，使得在同一时间内，只有一个线程能够执行这个方法或代码块。这种机制可以防止多个线程同时访问共享资源，从而避免了数据的不一致性。

**1.1 synchronized 的使用**

下面是一个简单的例子，演示了 `synchronized` 的使用：

javapublic class SynchronizedExample {
 private int count =0;

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

 public int getCount() {
 return count;
 }
}

在这个例子中，`increment()` 方法使用 `synchronized` 修饰符，这意味着每次只有一个线程能够执行这个方法。由于 `count` 是一个共享资源，因此使用 `synchronized` 可以保证 `count` 的值是正确的。

**1.2 synchronized 的实现**

`synchronized` 的实现基于 Java 中的锁机制。在 Java 中，每个对象都有一个内置的锁，称为 `monitor`。当你在一个方法或代码块上使用 `synchronized` 修饰符时，它会获得这个对象的锁，从而阻止其他线程进入这个方法或代码块。

下面是一个简单的例子，演示了 `synchronized` 的实现：

javapublic class SynchronizedExample {
 private Object lock = new Object();

 public void increment() {
 synchronized (lock) { // synchronized lock System.out.println("Thread " + Thread.currentThread().getName() + " is executing...");
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("Thread " + Thread.currentThread().getName() + " finished.");
 }
 }

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

 Thread thread1 = new Thread(() -> example.increment());
 Thread thread2 = new Thread(() -> example.increment());

 thread1.start();
 thread2.start();
 }
}

在这个例子中，我们使用 `synchronized` 修饰符来保护一个方法，这个方法会睡眠1000 毫秒。由于只有一个线程能够执行这个方法，因此我们可以看到两个线程之间的切换。

**2. 线程间的通信**

线程间的通信是指让不同的线程之间进行信息交换和同步。在 Java 中，有几种方式可以实现线程间的通信：

* **wait() 和 notify()**: 这两个方法可以用来使一个线程等待另一个线程的通知。
* **Lock**: Lock 是 Java 中的一个接口，它提供了更细粒度的锁机制，可以用来保护共享资源。
* **Condition**: Condition 是 Java 中的一个接口，它提供了一种方式让一个线程等待另一个线程的条件。

下面是一个简单的例子，演示了 `wait()` 和 `notify()` 的使用：

javapublic class WaitAndNotifyExample {
 private boolean flag = false;

 public void waitMethod() {
 synchronized (this) { // synchronized this while (!flag) {
 try {
 this.wait(); // wait for notification } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 System.out.println("Thread " + Thread.currentThread().getName() + " is notified.");
 }
 }

 public void notifyMethod() {
 synchronized (this) { // synchronized this flag = true;
 this.notify(); // notify the waiting thread }
 }

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

 Thread thread1 = new Thread(() -> example.waitMethod());
 Thread thread2 = new Thread(() -> example.notifyMethod());

 thread1.start();
 thread2.start();
 }
}

在这个例子中，我们使用 `wait()` 和 `notify()` 方法来使一个线程等待另一个线程的通知。

**3. 总结**

在本文中，我们学习了 Java 中的 `synchronized` 关键字和线程间的通信。我们了解了 `synchronized` 的实现机制以及它如何保护共享资源。我们还学习了 `wait()` 和 `notify()` 方法，以及它们如何使一个线程等待另一个线程的通知。

通过阅读本文，希望你能够理解 Java 中多线程编程的基本概念，并能够使用 `synchronized` 和线程间的通信来保护共享资源和实现线程间的信息交换。