java基础与并发



一、并发编程的挑战

1. 上下文切换

单核cpu也支持多线程，是通过给不同线程分配时间片来实现的，由于时间片很短，最终使得看起来是多个线程一起执行。当线程A切换到线程B执行时，会保存A的当前状态，以便下一次线程A重新获得时间片时重新加载之前的状态。从保存到加载的过程就是一次上下文切换。

因为线程有创建和上下文切换的开销，有可能导致并发执行的速度会比串行慢。

那么如何减少线程的上下文切换次数呢？

上下文切换是由于时间片机制引起的，那如果当前任务执行完才能执行下一个任务是否就不用上下文切换？或者将时间片的时间变长？

这样确实是很好，但是牺牲了公平性和响应性。而且涉及到操作系统调用cpu资源，显然是通过简单编程无法实现的。

如果从线程的角度来说，创建线程也有开销，就分配合适数量的线程。

实际上（当然是书上说的），有以下几种方式：

• 无锁并发编程

  如果当前线程获取的资源被加锁，那么OS会将保存其当前状态并让其他线程执行，也就是发生上下文切换。使用其他无锁方式即可，例如深度学习中需要预处理的数据量太大，就可以采用将数据拆分成多份分配给不同的线程（进程）进行，可以避免加锁带来的性能损失。

• CAS算法

  假设有一个共享的计数器，两个线程同时想要增加这个计数器的值。首先，每个线程会读取当前计数器的值。然后，它们会尝试通过CAS操作将这个值增加1。但是，如果两个线程同时读取到相同的值，只有一个线程能够成功地将新值写入计数器，而另一个线程则需要重新尝试。这样就不会使得线程阻塞导致上下文切换了。

• 使用最少线程
• 使用协程

  协程在执行过程中暂停和恢复不需要上下文切换

2. 资源限制

例如，服务器的带宽只有2Mb/s，某个资源的下载速度是1Mb/s每秒，系统启动10个线程下载资源，下载速度不会变成10Mb/s，所以在进行并发编程时，要考虑这些资源的限制。硬件资源限制有带宽的上传/下载速度、硬盘读写速度和CPU的处理速度。软件资源限制有数据库的连接数和socket连接数等。

资源限制情况下进行并发编程

根据不同的资源限制调整程序的并发度，比如限制并发执行的线程数量

二、并发机制的底层实现原理

Java代码在编译后会变成Java字节码，字节码被类加载器加载到JVM里，JVM执行字节码，最终需要转化为汇编指令在CPU上执行，Java中所使用的并发机制依赖于JVM的实现和CPU的指令。

1. volatile

如果一个变量被声明成volatile，Java线程内存模型确保所有线程看到这个变量的值是一致的。

下面介绍几个和CPU相关的专业术语

• 内存屏障：

  一种特殊的指令或者编译器内部的优化措施，用于控制指令的执行顺序和内存访问的顺序，以保证多核处理器或多线程环境下的内存可见性和一致性。

• 缓冲行

  Cache的基本单位

• 原子操作
• 缓冲行填充

  将内存中的数据写入缓存

• 缓存命中

  从缓存而不是内存中读取数据

• 写命中

  直接将数据写入缓存而不是内存

• 写缺失

  缓存中没有数据，需要先从内存中写入到缓存中

有volatile修饰的变量进行写操作时在多核处理器下引发了两件事情

1. 将当前处理器中变量所在缓存行的数据写回内存中
2. 使得其他处理器中对应的缓存行的数据无效
   

Doug lea使用volatile时，用一种追加字节的方式来优化队列出队和入队的性能。

LinkedTransferQueue使用一个内部类来定义队列的头节点（head）和尾节点（tail），而这个内部类PaddedAtomicReference相对于父类 AtomicReference只做了一件事情，就是将共享变量追加到64字节。我们可以来计算下，一个对象的引用占4个字节，它追加了15个变量（共占60个字节），再加上父类的value变量，一共64个字节。

为什么追加64字节能够提高并发编程的效率呢？

因为对于英特尔酷睿i7、酷睿、Atom和 NetBurst，以及Core Solo和Pentium M处理器的L1、L2或L3缓存的高速缓存行是64个字节宽，不支持部分填充缓存行，这意味着，如果队列的头节点和尾节点都不足64字节的话，处理器会将它们都读到同一个高速缓存行中，在多处理器下每个处理器都会缓存同样的头、尾节点，当一个处理器试图修改头节点时，会将整个缓存行锁定，那么在缓存一致性机制的作用下，会导致其他处理器不能访问自己高速缓存中的尾节点，而队列的入队和出队操作则需要不停修改头节点和尾节点，所以在多处理器的情况下将会严重影响到队列的入队和出队效率。Doug lea使用追加到64字节的方式来填满高速缓冲区的缓存行，避免头节点和尾节点加载到同一个缓存行，使头、尾节点在修改时不会互相锁定。

那么是不是在使用volatile时变量都应该追加到64字节呢？

缓存行非64字节宽的处理器不需要。如P6系列和奔腾处理器，它们的L1和L2高速缓存行是32个 字节宽。 

共享变量的写操作不频繁时不需要。因为使用追加字节的方式需要处理器读取更多的字节到高速缓冲区，这本身就会带来一定的性能消耗，如果共享变量不被频繁写的话，锁的几率也非常小，就没必要通过追加字节的方式来避免相互锁定。

2. synchronized

首先介绍一下Java对象的存储布局，一个Java对象在内存中存储的布局可以分为3块区域：对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。

1. 对象头（Object Header）： 对象头是Java对象的元数据，用于存储对象的标识信息和控制信息。对象头的内容通常包括对象的哈希码（HashCode）、锁信息（Lock）以及其他与对象状态相关的标志位。对象头的大小在不同的JVM实现中可能会有所不同，通常是8字节或更多。
2. 实例数据（Instance Data）： 实例数据是Java对象的成员变量和实例方法所占用的空间。Java对象中的每个成员变量都会在内存中分配相应的空间，成员变量的大小取决于其类型和对齐要求。实例数据的布局通常是按照在类中声明的顺序排列的。
3. 对齐填充（Padding）： 对齐填充是为了保证对象在内存中的对齐要求而添加的额外空间。由于内存对齐的要求，对象的大小通常会被调整为某个较小的值的倍数，以保证对象的起始地址是对齐的。这可能会导致对象中存在一些未使用的空间，称为对齐填充。

1. Mark Word（标记字）： Mark Word 是对象头中最重要的部分，它包含了对象的哈希码（HashCode）、锁状态、锁信息、GC 分代年龄等。Mark Word 的内容在不同的 JVM 实现中可能会有所不同，具体的结构和使用方式可能会有所差异。在一些 JVM 实现中，Mark Word 的大小通常为 4 字节或 8 字节。
2. 类型指针（Class Pointer）： 类型指针指向对象的类元数据（Class Metadata），用于确定对象所属的类以及调用对象方法时的动态分派。大小通常为4或8个字节。
3. 数组长度（Array Length）： 如果对象是数组对象，那么对象头中会包含一个用于存储数组长度的字段。该字段通常位于对象头的尾部，以便在对象的大小固定时，能够更有效地访问数组长度。通常也为4或8个字节。

在32位的虚拟机下，标记字占4个字节，Mark Word内部存储结构如下：

在64位虚拟机下：

java基础与并发

JVM基于进入和退出Monitor对象来实现方法同步和代码块同步。什么是Moniter对象？

monitor对象本质上是jvm用c语言定义的一个数据类型。对应的数据结构保存了线程同步所需的信息，比如保存了被阻塞的线程的列表。每个java对象都会与一个monitor相关联，可以由线程获取和释放。

monitor的作用就是限制同一时刻，只有一个线程能进入monitor框定的临界区，达到线程互斥，保护临界区中临界资源的安全，这称为线程同步使得程序线程安全。同时作为同步工具，它也提供了管理进程，线程状态的机制，比如monitor能管理因为线程竞争未能第一时间进入临界区的其他线程，并提供适时唤醒的功能。

同步方法jvm是使用ACC_SYNCHRONIZED方法访问标识符实现同步，同步代码块jvm是使用monitorenter和monitorexit指令包裹临界区实现同步。

JVM基于进入和退出Monitor对象来实现方法同步和代码块同步，但两者的实现细节不一样。代码块同步是使用monitorenter 和monitorexit指令实现的，而方法同步是使用另外一种方式实现的，细节在JVM规范里并没有 详细说明。但是，方法的同步同样可以使用这两个指令来实现。

任何对象都有 一个monitor与之关联，当且一个monitor被持有后，它将处于锁定状态。线程执行到monitorenter 指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获得对象的锁。

Java SE 1.6为了减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁”，在 Java SE1.6中，锁一共有4种状态，级别从低到高依次是：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏 向锁升级成轻量级锁后不能降级成偏向锁。这种锁升级却不能降级的策略，目的是为了提高 获得锁和释放锁的效率。

2.1 偏向锁

HotSpot的作者经过研究发现，大多数情况下，锁不仅不存在多线程竞争，而且总是由同 一线程多次获得，为了让线程获得锁的代价更低而引入了偏向锁。

当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS（compare and swap）操作来加锁和解锁，只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁。如果测试失败，则需要再测试一下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁）：如果没有设置，则使用CAS竞争锁；如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。

其实就是锁里面存了自己偏向哪个线程（上一次访问的线程），当一个新线程访问时如果是“被偏爱的”，就直接获得锁（类似缓存机制），降低获取锁的代价。

从这里可以看出偏向锁的使用场景是不存在或很少存在多线程竞争。

2.2 轻量级锁

线程在执行同步块之前，JVM会先在当前线程的栈桢中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中，官方称为Displaced Mark Word。然后线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁。

解锁时，会使用原子的CAS操作将Displaced Mark Word替换回到对象头，如果成功，则表示没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。

简单来说，就是加锁时线程里面要存被锁住对象的信息，即被锁住对象的标记字。如果“存信息”这个过程能成功，表示锁住了这个对象，如果失败就是多试几次“存信息”操作。

JDK 1.7/6 之前是普通自旋，会设定一个最大的自旋次数，默认是 10 次，超过这个阈值就停止自旋。JDK 1.7/6 之后，引入了适应性自旋。简单来说就是：这次自旋获取到锁了，自旋的次数就会增加；这次自旋没拿到锁，自旋的次数就会减少。

自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。

2.3 重量级锁

上面提到，试图抢占的线程自旋达到阈值，就会停止自旋，那么此时锁就会膨胀成重量级锁。当其膨胀成重量级锁后，其他竞争的线程进来就不会自旋了，而是直接阻塞等待，并且 Mark Word 中的内容会变成一个监视器（monitor）对象，用来统一管理排队的线程。

接下来我们看几个 ObjectMonitor 类关键的属性：

• ContentionQueue：是个队列，所有竞争锁的线程都会先进入这个队列中，可以理解为线程的统一入口，进入的线程会阻塞。
• EntryList：ContentionQueue 中有资格的线程会被移动到这里，相当于进行一轮初筛，进入的线程会阻塞。
• Owner：拥有当前 monitor 对象的线程，即 —— 持有锁的那个线程。
• OnDeck：与 Owner 线程进行竞争的线程，同一时刻只会有一个 OnDeck 线程在竞争。
• WaitSet：当 Owner 线程调用 方法被阻塞之后，会被放到这里。当其被唤醒之后，会重新进入 EntryList 当中，这个集合的线程都会阻塞。
• Count：用于实现可重入锁，synchronized 是可重入的。

当获取了轻量级锁的线程解锁时，尝试用cas 将 Mark Word 的值恢复给对象头，失败。这时会进入重量级解锁流程，即按照 Monitor 地址找到 Monitor 对象，设置 Owner 为 null ，唤醒 EntryList 中 BLOCKED 线程，完成锁的释放。

3. 原子操作的实现原理

原子操作（atomic operation）意为“不可被中断的一个或一系列操作”。

3.1 处理器如何实现原子操作

32位IA-32处理器使用基于对缓存加锁或总线加锁的方式来实现多处理器之间的原子操作。首先处理器会自动保证基本的内存操作的原子性。

处理器保证从系统内存中读取或者写 入一个字节是原子的，意思是当一个处理器读取一个字节时，其他处理器不能访问这个字节 的内存地址。

Pentium 6和最新的处理器能自动保证单处理器对同一个缓存行里进行16/32/64位 的操作是原子的，但是复杂的内存操作处理器是不能自动保证其原子性的，比如跨总线宽度、 跨多个缓存行和跨页表的访问。但是，处理器提供总线锁定和缓存锁定两个机制来保证复杂 内存操作的原子性。

举个例子，如果i=1，我们进行 两次i++操作，我们期望的结果是3，但是有可能结果是2。多个处理器同时从各自的缓存中读取变量i，分别进行加1操作，然后分别写入系统内存中。那么，想要保证读改写共享变量的操作是原子的，就必须保证CPU1读改写共享变量的时候，CPU2不能操作缓存了该共享变量内存地址的缓存。

1. 总线锁定

   所谓总线锁就是使用处理器提供的一个 LOCK＃信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该处理器可以独占共享内存。

   就是同一时刻只有一个cpu可以和内存通信，这使得锁定期间，其他处理器不能操作其他内存地址的数据，所以总线锁定的开销比较大，目前处理器在某些场合下使用缓存锁定代替总线锁定来进行优化。

2. 缓存锁定

   所谓“缓存锁定”是指内存区域如果被缓存在处理器的缓存行中，并且在Lock操作期间被锁定，那么当它执行锁操作回写到内存时，处理器不在总线上声明LOCK＃信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子性，因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效。

   当处理器需要更新被锁定的缓存行中的数据时，它会将数据写入到修改后的内存地址中，而不是原始的内存地址。这样做的目的是避免在更新数据时触发总线锁定（LOCK#）信号，从而减少处理器之间的竞争和通信开销。在内存中维护一个修改后的内存地址可以在一定程度上提高多线程程序的并发性能和扩展性。

当操作的数据不能被缓存在处理器内部，或操作的数据跨多个缓存行 （cache line）时，则处理器会调用总线锁定。 有些处理器不支持缓存锁定。对于Intel 486和Pentium处理器，就算锁定的内存区域在处理器的缓存行中也会调用总线锁定。

3.2 Java如何实现原子操作

在Java中可以通过锁和循环CAS的方式来实现原子操作

1. 循环CAS

从Java 1.5开始，JDK的并发包里提供了一些类来支持原子操作，如AtomicBoolean（用原子 方式更新的boolean值）、AtomicInteger（用原子方式更新的int值）和AtomicLong（用原子方式更 新的long值）。这些原子包装类还提供了有用的工具方法，比如以原子的方式将当前值自增1和 自减1。

CAS实现原子操作的三大问题：

• ABA

  CAS 操作是一种原子性的操作，用于在并发环境中实现无锁算法。它的基本原理是：如果当前共享变量的值等于预期值，则使用新值替换当前值；否则，不做任何操作。然而，当共享变量的值经历了 A->B->A 的变化过程时，CAS 操作可能会错误地认为共享变量的值没有被修改过。可以使用版本号或时间戳等机制来标识共享变量的变化历史，另一种解决 ABA 问题的方法是使用带有标记位的原子引用，例如 Java 中的 AtomicStampedReference 类。这个类可以保存一个对象引用和一个整数标记，当进行 CAS 操作时，先比较对象引用是否相等，再比较整数标记是否相等。

• 循环时间开销大
• 只能保证一个共享变量的原子操作

2. 使用锁机制

【1】https://www.cnblogs.com/qingshan-tang/p/12698705.html

【2】https://blog.csdn.net/yirenyuan/article/details/

版权声明：

本文来源网络，所有图片文章版权属于原作者，如有侵权，联系删除。

本文网址：https://www.bianchenghao6.com/h6javajc/2982.html