Java-多线程并发-4.线程同步

yueerba126

已于 2023-11-09 13:06:18 修改

阅读量333

点赞数

分类专栏： Java-多线程并发文章标签： java jvm 开发语言

于 2023-07-21 10:30:01 首次发布

本文链接：https://blog.csdn.net/yueerba126/article/details/131846309

版权

Java-多线程并发专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1️⃣ Java线程同步

当多个线程同时运行时，线程的调度由操作系统决定，程序本身无法决定。因此，任何一个线程都有可能在任何指令处被操作系统暂停，然后在某个时间段后继续执行。这个时候，有个单线程模型下不存在的问题就来了：如果多个线程同时读写共享变量，会出现数据不一致的问题。

2️⃣ 原子操作和非原子操作

🔒 原子操作

🚀 定义 原子操作 是指不可被线程调度机制中断的操作，一旦开始就运行到结束。
🛡️ 线程安全 它们自然保证了线程安全，因此不会出现竞态条件。
⚙️ 实现支持 这些操作依赖于底层硬件或操作系统特性来防止中断。

🔄 非原子操作

🚀 定义相对于 原子操作，非原子操作 包含一系列可以被中断的步骤。
🛡️ 竞态条件 这种中断可能导致多个线程间的操作交织在一起，从而产生竞态条件。

💡 非原子操作示例

对引用类型：
- 列表操作：
  - 读取列表当前引用
  - 添加元素到引用
  - 写回新的列表引用
- 映射操作：
  - 读取映射当前引用
  - 修改键值对
  - 写回新的映射引用
对基本类型：
- 整数操作：
  - 读取整数当前值
  - 值增加
  - 写回新的整数值
- 浮点操作：
  - 读取浮点数当前值
  - 执行运算
  - 写回新的浮点数值

🛠️ 替代方案

对引用类型：
- 使用线程安全集合类，如 ConcurrentLinkedQueue 或 CopyOnWriteArrayList
- 使用线程安全映射类，如 ConcurrentHashMap
对基本类型：
- 使用原子类，如 AtomicInteger 或 AtomicLong
- 应用锁机制，如 synchronized 或 ReentrantLock

✨ AtomicInteger:

🔒 CAS (Compare-And-Swap):
- 利用原子级的CAS指令实现更新。
🔄 无锁算法:
- 操作不依赖于传统锁，减少开销。
🔄 忙等待:
- 更新失败会不断重试。
⚠️ 缺陷:
- 在高争用下，自旋可能会增加CPU负荷。
- 在ABA场景会存在问题。
🌐 使用场景:
- 适用于计数器或状态值，以及高并发情况下的累加操作。

✍️ CopyOnWriteArrayList:

📦 写时复制机制:
- 修改时复制底层数组，保证读操作无锁。
🚀 读优先:
- 直接在当前数组上进行读操作。
⚠️ 缺陷:
- 写操作性能较低，因为需要复制整个数组。
- 内存占用较高，尤其是大型列表。
🌐 使用场景:
- 读多写少的并发场景，如配置信息的存储。

🗺️ ConcurrentHashMap:

🧵 分段锁技术:
- 数据分段，每段独立锁。
📈 高并发处理:
- 提高并发访问效率。
⚠️ 缺陷:
- 相比于 Hashtable 或同步的 HashMap，内存占用更高。
- 在较低的并发级别下，性能优势不明显。
🌐 使用场景:
- 多线程环境中需要大量数据插入、删除和访问的场景。

🔗 ConcurrentLinkedQueue:

🛠️ 无锁设计:
- 基于节点的无锁算法，使用CAS操作。
🚦 尾部追加:
- 新元素总是添加到队列尾部。
⚠️ 缺陷:
- 在队列元素较多时，某些操作如 size() 可能会较慢。
- 不适用于需要快速随机访问元素的场景。
🌐 使用场景:
- 适用于生产者-消费者模式，任务调度和消息传递。

📚 JVM内存模型

线程与内存交互：
- 每个线程有自己的工作内存
- 工作内存包含变量的本地副本
- 线程操作（读取、赋值）在工作内存中进行
- 然后操作结果同步回主内存
原子操作与内存：
- 原子操作通常在主内存中一次性完成
- 避免了工作内存与主内存同步问题
非原子操作的风险：
- 需要多步骤同步回主内存
- 可能导致数据在多线程间不一致

📝 Java内存模型的8种原子操作

🔒 lock(锁定) 作用于主内存，标记一个变量为线程独占状态。
📖 read(读取) 作用于主内存，传送变量值到线程的工作内存，为随后的load动作使用。
📥 load(载入) 作用于工作内存，载入read操作的值到工作内存的变量副本中。
🔄 use(使用) 作用于工作内存，传递工作内存的值给执行引擎。遇到需要使用变量的指令时执行。
✍️ assign(赋值) 作用于工作内存，把执行引擎的值赋给工作内存中的变量。遇到给变量赋值的指令时执行。
📤 store(存储) 作用于工作内存，传送工作内存的变量值给主内存，为随后的write操作使用。
📝 write(写入) 作用于主内存，将store传送的值写入主内存中的变量。
🔓 unlock(解锁) 作用于主内存，释放一个处于锁定状态的变量。释放后的变量可以被其他线程锁定。

📜 Java内存模型规定的原子操作规则

不允许 read 和 load、store 和 write 操作只有一个单独出现。它们必须按顺序执行，但之间可以插入其他指令。
不允许线程丢弃其最近的 assign 操作，即变量在工作内存中发生改变后，必须同步回主内存。
不允许线程无原因地同步数据从工作内存到主内存。
新的变量只能从主内存中“诞生”，不能直接在工作内存中使用未初始化的变量。
一个变量在同一时刻只允许一个线程执行 lock 操作，但同一线程可以重复执行 lock。
如果对变量执行 lock 操作，会清空工作内存中此变量的值。使用该变量前，需要重新执行 load 或 assign 操作。
不允许对未被 lock 锁定的变量执行 unlock，也不允许 unlock 一个被其他线程锁定的变量。
执行 unlock 操作前，必须先将此变量同步回主内存。

在这里插入图片描述

3️⃣ 加锁和解锁

🌟 原子操作与多线程

📌 在多线程编程中，对共享资源的访问需要特别小心，以确保数据的完整性和一致性。
📌 对一个共享资源的操作如果包含多条指令，并且这些指令的执行是不可中断的，则称该操作为原子操作。

📜 例子分析

提供了一个简单的例子，其中两个线程对一个共享的 int 变量进行操作。
- 一个线程对其进行10000次增加。
- 另一个线程对其进行10000次减少。
- 理论上，最终的结果应该是0，但实际上可能不是。

🔍 为什么会这样?

由于两个线程可能同时读取和写入变量，因此可能会出现数据不一致的情况。
- 例如，一个线程可能在读取变量值后被中断，而另一个线程在此期间修改了该值。
对于语句 n = n + 1;，它实际上对应了3条指令：ILOAD, IADD 和 ISTORE。

在这里插入图片描述

🔐 使用锁来解决

为了解决这个问题，可以使用锁来确保在任何时候只有一个线程能够访问共享资源。
- 在Java中，可以使用 synchronized 关键字来实现这一点。

synchronized(lock) {
    n = n + 1;
}

⚠️ 注意: 使用 synchronized 可以确保数据的完整性和一致性，但它也可能导致性能下降，因为它不允许多个线程同时进入同步代码块。

🚫 错误使用 synchronized 的例子

给出了一个错误的例子，其中两个线程使用了不同的锁对象。
- 这意味着它们可以同时获得各自的锁并同时访问共享资源，从而导致数据不一致。

👍 正确使用锁

当有多个共享资源时，应该为每个资源使用一个单独的锁，而不是使用一个全局锁。
- 这可以提高并发性，因为不同的资源可以被不同的线程同时访问，只要它们使用不同的锁。

📝 总结

在多线程环境中，确保共享资源的访问是原子的非常重要。
在Java中，可以使用 synchronized 关键字来确保代码块的原子性。
使用锁可以确保数据的完整性和一致性，但可能导致性能下降。
⚠️ 注意: 当选择锁对象时，确保所有需要同步访问共享资源的线程都使用相同的锁对象。

4️⃣ 不需要同步的操作

在多线程环境中，了解哪些操作是原子性的非常重要，因为原子操作不需要额外的同步机制来确保数据的完整性。

📌 JVM中定义的原子操作包括

📜 对基本数据类型（除了 long 和 double）的赋值。
- 例如: int n = m;
- 注意: long 和 double 是64位的数据类型，JVM规范没有明确它们的赋值操作是否是原子的。但在某些平台（如x64平台的JVM）中，它们的赋值被视为原子操作。
📜 对引用数据类型的赋值。
- 例如: List<String> list = anotherList;

🔍 需要同步的情况

如果操作只涉及到单个原子操作，那么不需要额外的同步。
- 例如在以下代码中:
```
public void set(int m) {
    synchronized(lock) {
        this.value = m;
    }
}

public void set(String s) {
    this.value = s;
}
```
  第一个 set 方法使用了 synchronized 关键字来同步，而第二个方法则没有。这是因为在第二个方法中，只有一个原子操作。
⚠️ 注意: 然而，当涉及到多个原子操作时，为了保证整体逻辑的正确性，需要使用同步机制。例如:
```
class Point {
    int x;
    int y;
    public void set(int x, int y) {
        synchronized(this) {
            this.x = x;
            this.y = y;
        }
    }
}
```
在这个例子中，虽然单独对 x 和 y 的赋值操作是原子的，但是为了保证 x 和 y 的整体状态的正确性，需要使用 synchronized 来同步整个 set 方法。

📝 总结

原子操作在多线程编程中非常有用，因为它们不需要额外的同步。
但是，当涉及到多个原子操作时，为了保证整体逻辑的正确性，通常需要使用同步机制，例如使用 synchronized 关键字。

5️⃣ 不但写需要同步，读也需要同步

🌟 分析

当多个线程尝试读取和修改共享数据时，如果不适当地同步操作，可能会导致数据不一致和其他意外行为。

📌 问题描述

给出的第一个 Point 示例：

当一个线程尝试设置 x 和 y 的值时，另一个线程可能在中间尝试读取这些值。
这可能会导致读取到一些中间状态的值，如 (110, 200)，这种状态在实际业务逻辑中可能是不合法的。

class Point {
    int x;
    int y;

    public void set(int x, int y) {
        synchronized(this) {
            this.x = x;
            this.y = y;
        }
    }

    public int[] get() {
        int[] copy = new int[2];
        copy[0] = x;
        copy[1] = y;
    }
}

🔍 解决方法

提出了一个很好的解决方法，即通过使用数组引用来转换非原子操作为原子操作。

在新的 Point 示例中，x 和 y 值被包装在一个数组中。
当设置新的 x 和 y 值时，会创建一个新的数组，并将其引用赋值给 ps。
- ⚠️ 注意: 这是一个原子操作，因为在Java中，引用赋值是原子的。
这样，读取 ps 时总是会得到一个一致的 x 和 y 值，不会出现中间状态。

📜 代码示例

class Point {
    int[] ps;

    public void set(int x, int y) {
        int[] ps = new int[] { x, y };
        this.ps = ps;
    }
}

🚫 但是…

尽管这种方法解决了写操作的问题，但读取 ps 的值时仍然需要注意。
如果要复制或访问 ps 数组的内容，仍然需要进行同步以确保数据的完整性和一致性。

📝 总结

在多线程环境中，合适地使用同步机制非常重要。
有时，可以通过巧妙的代码设计来避免显式的同步，例如使用原子操作或局部变量。
⚠️ 注意: 但在某些情况下，为了确保数据的完整性和一致性，仍然需要使用同步机制。

6️⃣ 不可变对象无需同步

🌟 不可变对象与多线程

📌 当多个线程访问一个不可变对象时：

由于对象的状态不会发生变化，所以无需同步。
String 和 List.of(...) 返回的列表都是不可变的，因此，在多线程环境中读取这些对象是安全的。

📜 示例分析

class Data {
    List<String> names;
    void set(String[] names) {
        this.names = List.of(names);
    }
    List<String> get() {
        return this.names;
    }
}

在上述代码中，set 方法创建了一个不可变列表，并将其赋值给 names 成员变量。
由于 List<String> 是不可变的，所以不需要同步读写操作。

🔍 局部变量与多线程

局部变量存储在线程的栈上，因此，每个线程都有其自己的局部变量的拷贝。
这意味着局部变量是线程安全的，不需要同步。
但是，如果局部变量引用的对象被赋值给一个共享变量或以其他方式“逃逸”到其他线程，那么这个对象可能需要同步。

📜 示例分析

class Status {
    List<String> names;
    int x;
    int y;
    void set(String[] names, int n) {
        List<String> ns = List.of(names);
        int step = n * 10;
        synchronized(this) {
            this.names = ns;
            this.x += step;
            this.y += step;
        }
    }
}

在上述代码中，ns 是一个局部变量，它引用一个不可变列表。
但由于 this.names = ns;，ns 引用的对象对其他线程变得可见，因此需要在设置 names, x, 和 y 时进行同步。

📝 总结

不可变对象在多线程环境中是安全的，因为它们的状态不会改变。
局部变量是线程安全的，因为每个线程都有其自己的拷贝。
⚠️ 注意: 如果局部变量引用的对象被赋值给一个共享变量或以其他方式“逃逸”到其他线程，那么这个对象可能需要同步。

7️⃣ `synchronized` 关键字

在Java中，synchronized关键字是用于控制多线程并发访问同步代码的机制，它可以确保被它修饰的代码块在任何时刻只能有一个线程进入执行。synchronized可以修饰普通方法、静态方法和代码块，根据修饰的目标，其行为和作用范围有所不同。

⚡️ synchronized修饰普通方法

🛡️ 特点当synchronized修饰普通方法时，该方法称为同步方法。
🎯 作用范围 整个方法。

🔑 锁对象 调用该同步方法的对象实例。

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

⚠️ 注意: 不同的对象实例有不同的锁，所以多个线程可以同时访问多个对象的同步方法，但不能同时访问同一个对象的同步方法。

⚡️ synchronized修饰静态方法

🛡️ 特点当synchronized修饰静态方法时，该方法称为静态同步方法。
🎯 作用范围 整个静态方法。

🔑 锁对象 该方法所在类的Class对象(xxx.class).

public static synchronized void staticSynchronizedMethod() {
    // ... 同步代码
}

⚠️ 注意: 由于静态方法不属于任何一个实例对象，所以它的锁是全局的。这意味着在任何时刻，只能有一个线程执行该静态同步方法。

⚡️ synchronized修饰代码块

🛡️ 特点 synchronized可以直接修饰代码块，这样可以精确控制需要同步的代码片段。
🎯 作用范围 被synchronized修饰的代码块。

🔑 锁对象 可以是任何对象，常用的有this和xxx.class。

synchronized(this) {
    // ... 同步代码
}

synchronized(MyClass.class) {
    // ... 同步代码
}

⚠️ 注意: 当使用this作为锁对象时，它锁定的是当前对象实例；而当使用xxx.class作为锁对象时，它锁定的是全局的Class对象，使得在任何时刻只有一个线程可以执行该代码块。

8️⃣ `volatile` 关键字

在Java中，volatile 是一个特殊的修饰符，主要用于修饰变量，确保多线程操作共享变量的内存可见性，但不提供原子性。

📌 主要特点

📜 内存可见性 当一个线程修改了一个 volatile 变量的值，新值对于其他线程立即可见。
📜 禁止指令重排序 volatile 变量前后的操作不会被JVM重排序。
📜 不保证原子性 volatile 仅确保读取和写入变量是原子的，但不保证复合操作的原子性。

🔍 使用场景

状态标记 例如，一个线程写入一个 volatile 的 boolean 标记，其他线程根据这个标记决定是否继续执行。

volatile boolean flag = true;

单例模式 双重检查锁定模式中使用 volatile 保证单例对象的可见性。

class Singleton {
    private static volatile Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

🚫 不适用的场景

复合操作 例如，检查然后更新的操作。下面的例子中，count++ 不是线程安全的，尽管 count 被声明为 volatile。

volatile int count = 0;
//...
count++;

⚠️ 注意在这种情况下，需要使用其他的同步机制，例如 synchronized 或 java.util.concurrent 包中的工具。

📝 总结

volatile 关键字主要确保多线程操作变量时的内存可见性。
它不提供复合操作的原子性。
在某些情况下，volatile 可以提供简单而高效的解决方案，但在需要原子性操作的场合，需要使用更强大的同步工具。

yueerba126

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java-多线程并发-4.线程同步

synchronized 可用于修饰普通方法、静态方法和代码块，接下来我们分别来看。当 synchronized 修饰普通方法时，被修饰的方法被称为同步方法，其作用范围是整个方法，作用的对象是调用这个方法的对象。当 synchronized 修饰静态方法时，其作用范围是整个程序，这个锁对于所有调用这个锁的对象都是互斥的。所谓的互斥，指的是同一时间只能有一个线程能使用，其他线程只能排队等待。
复制链接

扫一扫