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

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

基本概念：

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

---

线程同步的目的：

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

---

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

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

   示例：

   public synchronized void synchronizedMethod() {
       // 同步的代码块
   }
   

2. 对象锁： 在某些情况下，您可能需要使用特定的对象作为锁来控制同步。通过使用 synchronized 关键字来锁定特定的对象，可以确保多个线程之间对共享资源的访问是有序的。

   示例：

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

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

   示例：

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

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

   示例：

   private volatile int count = 0;
   

5. 等待和通知机制： 使用 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，则无法得到保障

可以看到几次的结果都不一样，没办法得到我们想要的答案。只有添加了同步锁，用于控制多个线程对共享资源的访问，才能防止数据的不一致性和并发问题。

总结

---

​ PS:这只是线程同步的一个简单示例，实际应用中可能涉及更复杂的场景和更多的同步机制。不过， 希望这个简单的示例可以帮助您理解如何使用 synchronized 来确保多线程环境下共享资源的安全访问。

作者：Stevedash

发表于：2023年8月14日 16点35分

来源：Java 多线程编程 | 菜鸟教程 (runoob.com)

注：本文内容基于个人学习理解，如有错误或疏漏，欢迎指正。感谢阅读！如果觉得有帮助，请点赞和分享。