Java多线程编程中的线程同步

基本概念：

线程同步是多线程编程中的一个重要概念，用于控制多个线程对共享资源的访问，以防止数据的不一致性和并发问题。
在多线程环境下，多个线程同时访问共享资源可能导致数据的竞争和不正确的结果。

线程同步的目的：

是确保多个线程按照特定的顺序和规则访问共享资源，以保证数据的正确性和一致性。

以下是一些常见的线程同步机制：

synchronized 关键字： 使用 synchronized 关键字可以在方法或代码块中标记为同步，确保同一时刻只有一个线程可以执行被标记的代码块。这可以防止多个线程同时访问被同步的资源。

示例：
```
public synchronized void synchronizedMethod() {
    // 同步的代码块
}
```
对象锁： 在某些情况下，您可能需要使用特定的对象作为锁来控制同步。通过使用 synchronized 关键字来锁定特定的对象，可以确保多个线程之间对共享资源的访问是有序的。

示例：
```
public void someMethod() {
    synchronized (lockObject) {
        // 同步的代码块
    }
}
```

ReentrantLock 类： ReentrantLock 是 Java 提供的一个可重入锁类，它提供了更灵活的同步机制，比传统的 synchronized 关键字更加强大。

示例：

import java.util.concurrent.locks.*;

Lock lock = new ReentrantLock();
public void someMethod() {
    lock.lock();
    try {
        // 同步的代码块
    } finally {
        lock.unlock();
    }
}

volatile 关键字： volatile 关键字用于修饰变量，保证多个线程之间对该变量的读取和写入操作是可见的。虽然 volatile 关键字不能完全替代锁，但在某些情况下可以用于简单的线程同步需求。

示例：
```
private volatile int count = 0;
```
等待和通知机制： 使用 wait() 和 notify()（或 notifyAll()）方法可以实现线程之间的等待和通知机制，用于控制线程的执行顺序和资源的访问。

示例：
```
synchronized (lock) {
    while (condition) {
        lock.wait();
    }
    // 执行逻辑
    lock.notify();
}
```

线程同步是多线程编程中必不可少的一部分，它可以帮助您避免数据竞争和并发问题，确保程序在多线程环境下的正确性和稳定性。不同的同步机制适用于不同的场景，我们可以根据具体的需求选择合适的方式来实现线程同步。

当涉及到线程同步时:

一个常见的示例是使用 synchronized 关键字来确保多个线程对共享资源的安全访问。以下是一个简单的示例，演示了如何使用 synchronized 来同步一个共享计数器

public class SynchronizedExample {

    private int count = 0;

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

    public synchronized int getCount() {
        return 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.getCount());
    }
}

输出结果如下：
在这里插入图片描述

在这个示例中，我们创建了一个名为 SynchronizedExample 的类，其中包含一个共享的计数器 count。通过将 increment 方法和 getCount 方法标记为 synchronized，我们确保了在同一时刻只有一个线程可以访问这些方法，从而保证了计数器的安全访问。

我们创建了两个线程来同时执行 increment 方法，每个线程都会将计数器增加 1000 次。通过调用 join 方法，我们等待这两个线程执行完毕后再输出最终的计数值。

若是不添加上sychronized，则无法得到保障

在这里插入图片描述