1.synchronized关键字
2.synchronize底层原理
3.用Java实现Actor模型（模仿Skynet）
4.后端面经-JavaAQS详解
5.Java并发编程解析 | 基于JDK源码解析Java领域中并发锁之StampedLock锁的同步设计思想与实现原理 (三)

synchronized关键字

       并发编程中的关键点在于数据同步、线程安全和锁。锁源编写线程安全的码同代码，核心在于管理对共享和可变状态的步锁访问。

       共享意味着变量可以被多个线程访问，机制而可变则意味着变量的同步莆田自助建站源码值在其生命周期内可以变化。

       当多个线程访问某个状态变量，锁源且有一个线程执行写入操作时，码同必须使用同步机制来协调对这些线程的步锁访问。

       Java中的机制主要同步机制是关键字synchronized，它提供了一种独占的同步加锁方式。

       以下是锁源关于synchronized关键字的几个方面：

       关键字synchronized的特性：

       不可中断：synchronized关键字提供了独占的加锁方式，一旦一个线程持有了锁对象，码同其他线程将进入阻塞状态或等待状态，步锁直到前一个线程释放锁，机制中间过程不可中断。

       原子性：synchronized关键字的不可中断性保证了它的原子性。

       可见性：synchronized关键字包含了两个JVM指令：monitor enter和monitor exit，它能够保证在任何时候任何线程执行到monitor enter时都必须从主内存中获取数据，而不是从线程工作内存获取数据，在monitor exit之后，工作内存被更新后的值必须存入主内存，从而保证了数据可见性。

       有序性：synchronized关键字修改的同步方法是串行执行的，但其所修饰的代码块中的指令顺序还是会发生改变的，这种改变遵守java happens-before规则。

       可重入性：如果一个拥有锁持有权的线程再次获取锁，则monitor的计数器会累加1，当线程释放锁的时候也会减1，直到计数器为0表示线程释放了锁的持有权，在计数器不为0之前，其他线程都处于阻塞状态。

       关键字synchronized的用法：

       synchronized关键字锁的是对象，修饰的可以是代码块和方法，但不能修饰class对象以及变量。

       在开发中最常用的是用synchronized关键字修饰对象，可以控制锁的单选按钮源码粒度，所以针对最常用的场景，先来看看它的字节码文件。

       TIPS：在使用synchronized关键字时注意事项

       锁膨胀：

       在jdk1.6之前，线程在获取锁时，如果锁对象已经被其他线程持有，此线程将挂起进入阻塞状态，唤醒阻塞线程的过程涉及到了用户态和内核态的切换，性能损耗比较大。

       synchronized作为亲儿子，混的太差肯定不行，在jdk1.6对其进行了优化，将锁状态分为了无锁状态、偏向锁、轻量级锁、重量级锁。

       锁的升级过程既是：

       在了解锁的升级过程之前，重点理解了monitor和对象头。

       每一个对象都与一个monitor相关联，monitor对象与实例对象一同创建并销毁，monitor是C++支持的一个监视器。锁对象的争夺即是争夺monitor的持有权。

       在OpenJdk源码中找到了ObjectMonitor的源码：

       owner：指向线程的指针。即锁对象关联的monitor中的owner指向了哪个线程表示此线程持有了锁对象。

       waitSet：进入阻塞等待的线程队列。当线程调用wait方法之后，就会进入waitset队列，可以等待其他线程唤醒。

       entryList：当多个线程进入同步代码块之后，处于阻塞状态的线程就会被放入entryList中。

       那什么是对象头呢？它与synchronized又有什么关系呢？

       在JVM中，对象在内存中分为3块区域：

       我们先通过一张图了解下在锁升级的过程中对象头的变化：

       接下来我们分析锁升级的过程：

       第一个分支锁标志为：

       当线程运行到同步代码块时，首先会判断锁标志位，如果锁标志位为，则继续判断偏向标志。

       如果偏向标志为0，则表示锁对象未被其他线程持有，算命逻辑源码可以获取锁。此时当前线程通过CAS的方法修改线程ID，如果修改成功，此时锁升级为偏向锁。

       如果偏向标志为1，则表示锁对象已经被占有。

       进一步判断线程id是否相等，相等则表示当前线程持有的锁对象，可以重入。

       如果线程id不相等，则表示锁被其他线程占有。

       需进一步判断持有偏向锁的线程的活动状态，如果原持有偏向锁线程已经不活动或者已经退出同步代码块，则表示原持有偏向锁的线程可以释放偏向锁。释放后偏向锁回到无锁状态，线程再次尝试获取锁。主要是因为偏向锁不会主动释放，只有其他线程竞争偏向锁的时候才会释放。

       如果原持有偏向锁的线程没有退出同步代码块，则锁升级为轻量级锁。

       偏向锁的流程图如下：

       第二个分支锁标志为：

       在第一个分支中我们了解到在如果偏向锁已经被其他线程占有，则锁会被升级为轻量级锁。

       此时原持有偏向锁的线程的栈帧中分配锁记录Lock Record，将对象头中的Mark Word信息拷贝到锁记录中，Mark Word的指针指向了原持有偏向锁线程中的锁记录，此时原持有偏向锁的线程获取轻量级锁，继续执行同步块代码。

       如果线程在运行同步块时发现锁的标志位为，则在当前线程的栈帧中分配锁记录，拷贝对象头中的Mark Word到锁记录中。通过CAS操作将Mark Word中的指针指向自己的锁记录，如果成功，则当前线程获取轻量锁。

       如果修改失败，则进入自旋，不断通过CAS的手机拍照源码方式修改Mark Word中的指针指向自己的锁记录。

       当自旋超过一定次数（默认次），则升级为重量锁。

       轻量级流程图如下图：

       第三个分支锁标志位为：

       锁标志为时，此时锁已经为重量锁，线程会先判断monitor中的owner指针指向是否为自己，是则获取重量锁，不是则会挂起。

       整个锁升级过程中的流程图如下，如果看懂了一定要自己画一遍。

       总结：

       synchronized关键字是一种独占的加锁方式，不可中断，保证了原子性、可见性和有序性。

       synchronized关键字可用于修饰方法和代码块，但不能用于修饰变量和类。

       多线程在执行同步代码块时获取锁的过程在不同的锁状态下不一样，偏向锁是修改Mark Word中的线程ID，轻量锁是修改Mark Word的指针指向自己的锁记录，重量锁是修改monitor中的指针指向自己。

       今天就学到这里了！收工！

synchronize底层原理

       synchronize底层原理是什么?我们先通过反编译下面的代码来看看Synchronized是如何实现对代码块进行同步的：

       1 package com.paddx.test.concurrent;

       2

       3 public class SynchronizedDemo {

       4 public void method() {

       5 synchronized (this) {

       6 System.out.println(Method 1 start);

       7 }

       8 }

       9 }

       反编译结果：

       关于这两条指令的作用，我们直接参考JVM规范中描述：

       monitorenter ：

       Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref, as follows:

        If the entry count of the monitor associated with objectref is zero, the thread enters the monitor and sets its entry count to one. The thread is then the owner of the monitor.

        If the thread already owns the monitor associated with objectref, it reenters the monitor, incrementing its entry count.

        If another thread already owns the monitor associated with objectref, the thread blocks until the monitors entry count is zero, then tries again to gain ownership.

       这段话的大概意思为：

       每个对象有一个监视器锁(monitor)。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程：

       1、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。

       2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.

       3.如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的人人视频源码进入数为0，再重新尝试获取monitor的所有权。

       monitorexit：

       The thread that executes monitorexit must be the owner of the monitor associated with the instance referenced by objectref.

       The thread decrements the entry count of the monitor associated with objectref. If as a result the value of the entry count is zero, the thread exits the monitor and is no longer its owner. Other threads that are blocking to enter the monitor are allowed to attempt to do so.

       这段话的大概意思为：

       执行monitorexit的线程必须是objectref所对应的monitor的所有者。

       指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。

       通过这两段描述，我们应该能很清楚的看出Synchronized的实现原理，Synchronized的语义底层是通过一个monitor的对象来完成，其实wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

       我们再来看一下同步方法的反编译结果：

       源代码：

       1 package com.paddx.test.concurrent;

       2

       3 public class SynchronizedMethod {

       4 public synchronized void method() {

       5 System.out.println(Hello World!);

       6 }

       7 }

       反编译结果：

       从反编译的结果来看，方法的同步并没有通过指令monitorenter和monitorexit来完成(理论上其实也可以通过这两条指令来实现)，不过相对于普通方法，其常量池中多了ACC_SYNCHRONIZED标示符。JVM就是根据该标示符来实现方法的同步的：当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。 其实本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。

用Java实现Actor模型（模仿Skynet）

       Actor模型是种常见的并发模型，与共享内存（同步锁）不同，它将程序划分为多个独立计算单元——Actor，每个Actor独立管理资源，不同Actor间通过消息传递交互。优势在于全异步执行，避免线程阻塞，提高CPU使用率，且无需考虑加锁和线程同步问题。

       Actor模型在业界应用广泛，如游戏服务器框架Skynet、编程语言Erlang。Java下应用较少，知名的是基于Scala的Akka。但Actor模型并非万能，异步编程需编写更多回调代码，原本一步拆成多步，增加代码复杂度。

       本文以学习研究目的，使用Java实现简化Actor模型，功能模仿Skynet，包括：

       完整源代码在GitHub可获取。关键代码与设计思路如下。

       Actor是Actor模型核心概念，每个Actor管理资源，与其它Actor通过Message通信。

       Actor由单线程驱动，类为抽象，处理消息的`handleMessage`方法需具体类重载实现。

       Node代表独立Java进程，有自己的IP和端口，内部可运行多个Actor。Node间通过异步网络通信发送消息，Actor仅绑定一个Node。

       ActorSystem是Actor管理系统，外部调用API入口，提供创建Actor、发送消息、休眠等功能。

       ActorSystem初始化分为三步：读取集群配置、绑定Node、初始化自身，包括定时器和Netty服务端初始化。Node间通信异步，客户端和服务端使用Netty做。

       创建Actor调用`newActor`方法，指定具体类和Actor名，确保Node内唯一。创建时绑定Node，调用`start`方法初始化，将名与Actor映射。

       发送消息核心是`send`方法，指定目标Node、Actor名、命令名和参数，可封装为Message。

       `currThreadActor`变量记录当前线程的Actor，简化消息发送时指定来源信息。若目标与来源相同，直接添加消息；否则，通过网络通信实现，使用Netty做序列化和反序列化。

       休眠Actor通过`sleep`方法实现，指定毫秒数、回调命令及参数。底层通过定时任务实现阻塞。

       ActorSystem使用定时器管理定时任务，添加新任务后轮询处理。考虑优化避免多线程同时创建Channel。

       程序示例在test包内，启动Node后打印日志，验证Actor模型工作方式。

       总结，本文展示了使用Java实现简化Actor模型的完整流程，实现基础功能。造轮子旨在深入理解Actor模型，语言只是实现工具。相信本文有助于读者深入理解Actor模型。

后端面经-JavaAQS详解

       AQS是什么？

       AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如常用的ReentrantLock。简单来说，AQS定义了一套框架，来实现同步类。

       AQS的核心思想是对于共享资源，维护一个双端队列来管理线程，队列中的线程依次获取资源，获取不到的线程进入队列等待，直到资源释放，队列中的线程依次获取资源。AQS的基本框架如图所示：

       资源state变量表示共享资源，通常是int类型。CLH双向队列是一种基于逻辑队列非线程饥饿的自旋公平锁，具体介绍可参考此篇博客。CLH中每个节点都表示一个线程，处于头部的节点获取资源，而其他资源则等待。Node的方法和属性值如图所示：其中,

       一般来说，一个同步器是资源独占模式或者资源共享模式的其中之一，因此tryAcquire(int)和tryAcquireShared(int)只需要实现一个即可，tryRelease(int)和tryReleaseShared(int)同理。但是同步器也可以实现两种模式的资源获取和释放，从而实现独占和共享两种模式。

       acquire(int)是获取资源的顶层入口，tryAcquire(int)是获取资源的方法，需要自定义同步器实现。addWaiter(Node.EXCLUSIVE)是将线程加入等待队列的尾部，acquireQueued(Node node, int arg)将线程阻塞在等待队列中，直到获取到资源后才返回。

       release(int)是释放资源的顶层入口方法，tryRelease(int)是释放资源的方法，需要自定义同步器自己实现。unparkSuccessor(h)是唤醒后继节点的方法。

       acquireShared(int)和releaseShared(int)是使用共享模式获取共享资源的顶层入口方法，tryAcquireShared(arg)是获取共享资源的方法，doAcquireShared(arg)将线程阻塞在等待队列中，直到获取到资源后才返回。releaseShared(int)是释放共享资源的顶层入口方法，doReleaseShared()方法释放共享资源。

       面试问题模拟：AQS是接口吗？有哪些没有实现的方法？看过相关源码吗？

       A：AQS定义了一个实现同步类的框架，实现方法主要有tryAquire和tryRelease，表示独占模式的资源获取和释放，tryAquireShared和tryReleaseShared表示共享模式的资源获取和释放。源码分析如上文所述。

Java并发编程解析 | 基于JDK源码解析Java领域中并发锁之StampedLock锁的设计思想与实现原理 (三)

       在并发编程领域，核心问题涉及互斥与同步。互斥允许同一时刻仅一个线程访问共享资源，同步则指线程间通信协作。多线程并发执行历来面临两大挑战。为解决这些，设计原则强调通过消息通信而非内存共享实现进程或线程同步。

       本文探讨的关键术语包括Java语法层面实现的锁与JDK层面锁。Java领域并发问题主要通过管程解决。内置锁的粒度较大，不支持特定功能，因此JDK在内部重新设计，引入新特性，实现多种锁。基于JDK层面的锁大致分为4类。

       在Java领域，AQS同步器作为多线程并发控制的基石，包含同步状态、等待与条件队列、独占与共享模式等核心要素。JDK并发工具以AQS为基础，实现各种同步机制。

       StampedLock（印戳锁）是基于自定义API操作的并发控制工具，改进自读写锁，特别优化读操作效率。印戳锁提供三种锁实现模式，支持分散操作热点与削峰处理。在JDK1.8中，通过队列削峰实现。

       印戳锁基本实现包括共享状态变量、等待队列、读锁与写锁核心处理逻辑。读锁视图与写锁视图操作有特定队列处理，读锁实现包含获取、释放方式，写锁实现包含释放方式。基于Lock接口的实现区分读锁与写锁。

       印戳锁本质上仍为读写锁，基于自定义封装API操作实现，不同于AQS基础同步器。在Java并发编程领域，多种实现与应用围绕线程安全，根据不同业务场景具体实现。

       Java锁实现与运用远不止于此，还包括相位器、交换器及并发容器中的分段锁。在并发编程中，锁作为实现方式之一，提供线程安全，但实际应用中锁仅为单一应用，提供并发编程思想。

       本文总结Java领域并发锁设计与实现，重点介绍JDK层面锁与印戳锁。文章观点及理解可能存在不足，欢迎指正。技术研究之路任重道远，希望每一份努力都充满价值，未来依然充满可能。