简栈

作者：薛8

来源：https://juejin.im/post/5c890b4a51882501351d5929

AQS简介

AbstractQueuedSynchronizer抽象队列同步器，简称为AQS，可用于构建阻塞锁或者其他相关同步器的基础框，是Java并发包的基础工具类。通过AQS这个框架可以对同步状态原子性管理、线程的阻塞和解除阻塞、队列的管理进行统一管理。
AQS是抽象类，并不能直接实例化，当需要使用AQS的时候需要继承AQS抽象类并且重写指定的方法，这些重写方法包括线程获取资源和释放资源的方式(如ReentractLock通过分别重写线程获取和释放资源的方式实现了公平锁和非公平锁)，同时子类还需要负责共享变量state的维护，如当state为0时表示该锁没有被占，大于0时候代表该锁被一个或多个线程占领(重入锁)，而队列的维护(获取资源失败入队、线程唤醒、线程的状态等)不需要我们考虑，AQS已经帮我们实现好了。AQS的这种设计模式采用的正是模板方法模式。
总结起来子类的任务有：

1. 通过CAS操作维护共享变量state。
2. 重写资源的获取方式。
3. 重写资源释放的方式。

如果对CAS和Java内存模型还不清楚的，建议先了解这两者之后再食用本文，效果更佳！CAS原理分析及ABA问题详解 什么是Java内存模型？

完成以上三个任务即可实现自己的锁。
AQS作为J.U.C的工具类，面向的是需要实现锁的实现者，而锁面向的是锁的使用者，这两者的区别还是需要搞清楚的。

AQS数据结构

先看AQS有哪些重要的成员变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 头结点，你直接把它当做 当前持有锁的线程 可能是最好理解的
private transient volatile Node head;

// 阻塞的尾节点，每个新的节点进来，都插入到最后，也就形成了一个链表
private transient volatile Node tail;

// 这个是最重要的，不过也是最简单的，代表当前锁的状态，0代表没有被占用，大于0代表有线程持有当前锁
// 之所以说大于0，而不是等于1，是因为锁可以重入嘛，每次重入都加上1
private volatile int state;

// 代表当前持有独占锁的线程，举个最重要的使用例子，因为锁可以重入
// reentrantLock.lock()可以嵌套调用多次，所以每次用这个来判断当前线程是否已经拥有了锁
// if (currentThread == getExclusiveOwnerThread()) {state++}
private transient Thread exclusiveOwnerThread; //继承自AbstractOwnableSynchronizer

基本概念

1、什么是序列化和反序列化

（1）Java序列化是指把Java对象转换为字节序列的过程，而Java反序列化是指把字节序列恢复为Java对象的过程；

（2）序列化：对象序列化的最主要的用处就是在传递和保存对象的时候，保证对象的完整性和可传递性。序列化是把对象转换成有序字节流，以便在网络上传输或者保存在本地文件中。序列化后的字节流保存了Java对象的状态以及相关的描述信息。序列化机制的核心作用就是对象状态的保存与重建。

（3）反序列化：客户端从文件中或网络上获得序列化后的对象字节流后，根据字节流中所保存的对象状态及描述信息，通过反序列化重建对象。

（4）本质上讲，序列化就是把实体对象状态按照一定的格式写入到有序字节流，反序列化就是从有序字节流重建对象，恢复对象状态。

2、为什么需要序列化与反序列化

我们知道，当两个进程进行远程通信时，可以相互发送各种类型的数据，包括文本、图片、音频、视频等， 而这些数据都会以二进制序列的形式在网络上传送。

那么当两个Java进程进行通信时，能否实现进程间的对象传送呢？答案是可以的！如何做到呢？这就需要Java序列化与反序列化了！

换句话说，一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送；另一方面，接收方需要从字节序列中恢复出Java对象。

SimpleDateFormat是Java提供的一个格式化和解析日期的工具类，日常开发中应该经常会用到，但是由于它是线程不安全的，多线程公用一个SimpleDateFormat实例对日期进行解析或者格式化会导致程序出错。

代码示例演示

写一段小Demo来模拟多线程下SimpleDateFormat做时间格式化的时候报错,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package com.vernon.test.demo.jdk.text;
import java.text.ParseException;
import java.text.SimpleDateFormat;
/**
 * Created with vernon-test
 * Description：
 * User：chenyuan
 * Date：2019/3/20 Time：2:03 PM
 */
public class SimpleDateFormatCase {
    //1、创建单例实例
    static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    public static void main(String[] args) {
        //2、创建多个线程，并启动
        for (int i = 0; i < 10; ++i) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    try {
                      	//3、使用单例日期实例解析文本
                        System.out.println(sdf.parse("2017-12-13 15:17:27"));
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }
                }
            });
	          //4、启动线程
            thread.start();
        }
    }
}

控制台正常的情况： 运气好~

1
2
3
4
5
6
7
8
9
10
11
12

Connected to the target VM, address: '127.0.0.1:57434', transport: 'socket'
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Disconnected from the target VM, address: '127.0.0.1:57434', transport: 'socket'

控制台非正常的情况 运气不好~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

Connected to the target VM, address: '127.0.0.1:57756', transport: 'socket'
Exception in thread "Thread-2" Exception in thread "Thread-0" java.lang.NumberFormatException: multiple points
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.vernon.test.demo.jdk.text.SimpleDateFormatCase$1.run(SimpleDateFormatCase.java:23)
	at java.lang.Thread.run(Thread.java:748)
java.lang.NumberFormatException: multiple points
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.vernon.test.demo.jdk.text.SimpleDateFormatCase$1.run(SimpleDateFormatCase.java:23)
	at java.lang.Thread.run(Thread.java:748)
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Fri Dec 12 15:17:27 CST 2217
Thu Dec 13 15:17:27 CST 2012
Wed Dec 13 15:17:27 CST 2017
Wed Dec 13 15:17:27 CST 2017
Fri Jun 09 15:17:27 CST 5881628
Disconnected from the target VM, address: '127.0.0.1:57756', transport: 'socket'

通过IntelliJ IDEA的功能查看一下SimpleDateFormat的一个类关系图：

Map家族介绍

我们都知道HashMap是线程不安全的，但是HashMap的使用频率在所有Map中确实属于比较高的。因为它可以满足我们大多数的场景了。

看一眼Map家族的关系图：

Map是一个接口，我们常用的实现类有HashMap、LinkedHashMap、TreeMap，HashTable。

HashMap

HashMap根据key的·值来保存value，需要注意的是，HashMap不保证遍历的顺序和插入的顺序是一致的。HashMap允许有一条记录的key为null，但是对值是否为null不做要求。

HashTable

HashTable类是线程安全的，它使用synchronize来做线程安全，全局只有一把锁，在线程竞争比较激烈的情况下hashtable的效率是比较低下的。因为当一个线程访问hashtable的同步方法时，其他线程再次尝试访问的时候，会进入阻塞或者轮询状态，比如当线程1使用put进行元素添加的时候，线程2不但不能使用put来添加元素，而且不能使用get获取元素。所以，竞争会越来越激烈。相比之下，ConcurrentHashMap使用了分段锁技术来提高了并发度，不在同一段的数据互相不影响，多个线程对多个不同的段的操作是不会相互影响的。每个段使用一把锁。所以在需要线程安全的业务场景下，推荐使用ConcurrentHashMap，而HashTable不建议在新的代码中使用，如果需要线程安全，则使用ConcurrentHashMap，否则使用HashMap就足够了。

LinkedHashMap

前言

要想深入了解Java并发编程，就要先理解好Java内存模型，而要理解Java内存模型又不得不从硬件、计算机内存模型说起，本文从计算机内存模型产生的原因、解决的问题谈起，然后再对Java模型进行介绍，最后对计算机内存模型和Java内存模型进行总结，希望大家看完本文之后有所收获！

CPU工作过程及出现的问题

CPU执行过程

大家都知道，计算机在执行程序时，每条指令都是在CPU中执行的，而执行的时候，又免不了要和数据打交道，而计算机上面的临时数据，是储存在主存中的。

计算机内存包括高速缓存和主存。

我们知道CPU执行指令的速度比从主存读取数据和向主存写入数据快很多，所以为了高效利用CPU，CPU增加了**高速缓存(cache)**来匹配CPU的执行速度，最终程序的执行过程如下

1. 首先会将数据从主存中复制一份到CPU的高速缓存中
2. 当CPU执行计算的时候就可以直接从高速缓存中读取数据和写入数据
3. 当运算结束后，再将高速缓存的数据更新到主存中

缓存一致性问题

上面的执行过程在单线程情况下并没有问题，但是在多线程情况下就会出现问题，因为CPU如果含有多个核心，则每个核心都有自己独占高速缓存，如果出现多个线程同时执行同一个操作，那么结果是无法预知。例如2个线程同时执行i++，假设i的初始值是0，那么我们希望2个线程执行完成之后i的值变为2，但是事实会是这样吗？

如何理解Linux的上下文切换

• Linux 是一个多任务操作系统，它支持同时运行的任务数量远大于 CPU 个数。其实这些任务没有真正的同时运行，是因为系统在很短的时间内，将 CPU 轮流分配给它们，造成多任务同时运行的错觉。
• 而在每个任务运行前，CPU 都需要知道任务从哪里加载、从哪里开始运行，需要系统事先设置好 CPU 寄存器和程序计数器。CPU 寄存器是 CPU 内置的容量小、速度极快的内存。而程序计数器则是用来存储 CPU 正在执行的指令位置、或即将执行的下一条指令位置。它们都是 CPU 在运行任务前必须依赖的环境，也被叫做 CPU 上下文。
• 上下文切换，就是先把前一个任务的 CPU 上下文保存起来，然后加载新任务的上下文到这些寄存器和程序计数器，最后再跳到程序计数器所指的新位置，运行新任务。而这些保存下来的上下文，会存储在系统内核中，并在任务重新调度执行时再次加载进来。这样就能保证任务原来的状态不受影响，让任务看起来还是连续运行。

根据任务的不同，CPU 的上下文切换可以分为几个不同的场景，也就是：进程上下文切换、线程上下文切换、中断上下文切换。

进程上下文切换

1、用户空间与内核空间

Linux 按照特权等级，把进程的运行空间分为内核空间和用户空间，分别对应着 CPU 特权等级的 Ring 0 和 Ring 3。

• 内核空间(Ring 0)具有最高权限，可以直接访问所有资源。
• 用户空间(Ring 3)只能访问受限资源，不能直接访问内存等硬件设备，必须通过系统调用陷入内核中才能访问这些特权资源。
• 进程既可以在用户空间运行，又可以在内核空间运行。在用户空间运行时被称为进程的用户态，而陷入内核空间的时候，被称为进程的内核态。

2、系统调用

从用户态到内核态的转变，需要通过系统调用来完成。比如查看文件时，需要执行多次系统调用：open、read、write、close等。系统调用的过程如下：

• 首先，把 CPU 寄存器里原来用户态的指令位置保存起来
• 为了执行内核代码，CPU 寄存器需要更新为内核态指令的新位置，最后跳转到内核态运行内核任务。
• 系统调用结束后，CPU 寄存器需要恢复原来保存的用户态，然后再切换到用户空间，继续运行进程
• 所以，一次系统调用的过程，其实是发生了两次 CPU 上下文切换。

前言

上一篇文章介绍了多线程的概念及synchronized的使用方法《synchronized的使用（一）》，但是仅仅会用还是不够的，只有了解其底层实现才能在开发过程中运筹帷幄，所以本篇探讨synchronized的实现原理及锁升级(膨胀)的过程。

synchronized实现原理

synchronized是依赖于JVM来实现同步的，在同步方法和代码块的原理有点区别。

同步代码块

我们在代码块加上synchronized关键字

1
2
3
4
5

public void synSay() {
    synchronized (object) {
        System.out.println("synSay----" + Thread.currentThread().getName());
    }
}

编译之后，我们利用反编译命令javap -v xxx.class查看对应的字节码，这里为了减少篇幅，我就只粘贴对应的方法的字节码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

public void synSay();
  descriptor: ()V
  flags: ACC_PUBLIC
  Code:
    stack=3, locals=3, args_size=1
       0: aload_0
       1: getfield      #2                  // Field object:Ljava/lang/String;
       4: dup
       5: astore_1
       6: monitorenter
       7: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      10: new           #4                  // class java/lang/StringBuilder
      13: dup
      14: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
      17: ldc           #6                  // String synSay----
      19: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      22: invokestatic  #8                  // Method java/lang/Thread.currentThread:()Ljava/lang/Thread;
      25: invokevirtual #9                  // Method java/lang/Thread.getName:()Ljava/lang/String;
      28: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      31: invokevirtual #10                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      34: invokevirtual #11                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      37: aload_1
      38: monitorexit
      39: goto          47
      42: astore_2
      43: aload_1
      44: monitorexit
      45: aload_2
      46: athrow
      47: return
    Exception table:
       from    to  target type
           7    39    42   any
          42    45    42   any
    LineNumberTable:
      line 21: 0
      line 22: 7
      line 23: 37
      line 24: 47
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          0      48     0  this   Lcn/T1;
    StackMapTable: number_of_entries = 2
      frame_type = 255 /* full_frame */
        offset_delta = 42
        locals = [ class cn/T1, class java/lang/Object ]
        stack = [ class java/lang/Throwable ]
      frame_type = 250 /* chop */
        offset_delta = 4

可以发现synchronized同步代码块是通过加monitorenter和monitorexit指令实现的。
每个对象都有个**监视器锁(monitor) **，当monitor被占用的时候就代表对象处于锁定状态，而monitorenter指令的作用就是获取monitor的所有权，monitorexit的作用是释放monitor的所有权，这两者的工作流程如下：
monitorenter：

前言

零拷贝（英语：Zero-copy）技术是指计算机执行操作时，CPU不需要先将数据从某处内存复制到另一个特定区域。这种技术通常用于通过网络传输文件时节省CPU周期和内存带宽。

零拷贝操作减少了在用户空间与内核空间之间切换模式的次数。

举例来说，如果要读取一个文件并通过网络发送它，传统方式下如下图，传统的I/O操作进行了4次用户空间与内核空间的上下文切换，以及4次数据拷贝。其中4次数据拷贝中包括了2次DMA拷贝和2次CPU拷贝。通过零拷贝技术完成相同的操作，减少了在用户空间与内核空间交互，并且不需要CPU复制数据。

linux中零拷贝技术

Linux系统的“用户空间”和“内核空间”

从Linux系统上看，除了引导系统的BIN区，整个内存空间主要被分成两个部分：内核空间(Kernel space)、用户空间(User space)。

“用户空间”和“内核空间”的空间、操作权限以及作用都是不一样的。

内核空间是Linux自身使用的内存空间，主要提供给程序调度、内存分配、连接硬件资源等程序逻辑使用；用户空间则是提供给各个进程的主要空间。

前提

这篇文章主要分析一下Introspector(内省)的用法。Introspector是一个专门处理JavaBean的工具类，用来获取JavaBean里描述符号，常用的JavaBean的描述符号相关类有BeanInfo、PropertyDescriptor，MethodDescriptor、BeanDescriptor、EventSetDescriptor和ParameterDescriptor。下面会慢慢分析这些类的使用方式，以及Introspector的一些特点。

JavaBean是什么

JavaBean是一种特殊（其实说普通也可以，也不是十分特殊）的类，主要用于传递数据信息，这种类中的方法主要用于访问私有的字段，且方法名符合某种命名规则（字段都是私有，每个字段具备Setter和Getter方法，方法和字段命名满足首字母小写驼峰命名规则）。如果在两个模块之间传递信息，可以将信息封装进JavaBean中，这种对象称为值对象(Value Object)或者VO。这些信息储存在类的私有变量中，通过Setter、Getter方法获得。JavaBean的信息在Introspector里对应的概念是BeanInfo，它包含了JavaBean所有的Descriptor(描述符)，主要有PropertyDescriptor，MethodDescriptor(MethodDescriptor里面包含ParameterDescriptor)、BeanDescriptor和EventSetDescriptor。

属性Field和属性描述PropertiesDescriptor的区别

如果是严格的JavaBean(Field名称不重复，并且Field具备Setter和Getter方法)，它的PropertyDescriptor会通过解析Setter和Getter方法，合并解析结果，最终得到对应的PropertyDescriptor实例。所以PropertyDescriptor包含了属性名称和属性的Setter和Getter方法(如果存在的话)。

内省Introspector和反射Reflection的区别

• Reflection：反射就是运行时获取一个类的所有信息，可以获取到类的所有定义的信息（包括成员变量，成员方法，构造器等）可以操纵类的字段、方法、构造器等部分。可以想象为镜面反射或者照镜子，这样的操作是带有客观色彩的，也就是反射获取到的类信息是必定正确的。
• Introspector：内省基于反射实现，主要用于操作JavaBean，基于JavaBean的规范进行Bean信息描述符的解析，依据于类的Setter和Getter方法，可以获取到类的描述符。可以想象为“自我反省”，这样的操作带有主观的色彩，不一定是正确的(如果一个类中的属性没有Setter和Getter方法，无法使用内省)。

常用的内省相关类

主要介绍一下几个核心类所提供的方法。

Linux整体架构图

我们先来看一张Linux整体架构图。

系统调用

​ 系统调用时操作系统的最小功能单位。根据不同的应用场景，不同的Linux发行版本提供的系统调用数量也不尽相同，大致在240-350之间。这些系统调用组成了用户态跟内核态交互的基本接口，例如：用户态想要申请一块20K大小的动态内存，就需要brk系统调用，将数据段指针向下偏移，如果用户态多处申请20K动态内存，同时又释放呢？这个内存的管理就变得非常的复杂。

库函数

​ 库函数就是屏蔽这些复杂的底层实现细节，减轻程序员的负担，从而更加关注上层的逻辑实现。它对系统调用进行封装，提供简单的基本接口给用户，这样增强了程序的灵活性，当然对于简单的接口，也可以直接使用系统调用访问资源，例如：open()，write()，read()等等。库函数根据不同的标准也有不同的版本，例如：glibc库，posix库等。

Shell

​ Shell顾名思义，就是外壳的意思。就好像把内核包裹起来的外壳。它是一种特殊的应用程序，俗称命令行。为了方便用户和系统交互，一般一个Shell对应一个终端，呈现给用户交互窗口。当然Shell也是编程的，它有标准的shell语法，符合其语法的文本叫Shell脚本。很多人都会用Shell脚本实现一些常用的功能，可以提高工作效率。

为什么要区分用户态与内核态？