JAVA-多线程

atomic提供了3个类用于原子更新基本类型：分别是AtomicInteger原子更新整形，AtomicLong原子更新长整形，AtomicBoolean原子更新bool值

getAndIncremen的实现代码

getAndAddInt的实现

atomic里提供了三个类用于原子更新数组里面的元素，分别是：

　　AtomicIntegerArray：原子更新整形数组里的元素

　　AtomicLongArray：原子更新长整形数组里的元素

　　AtomicReferenceArray：原子更新引用数组里的元素

以AtomicIntegerArray为例来说明

常见方法如下

原子更新基本类型的AtomicInteger只能更新一个变量，如果要原子更新多个变量，就需要使用原子更新引用类型提供的类了。原子引用类型atomic包主要提供了以下几个类：
AtomicReference：原子更新引用类型

AtomicReferenceFieldUpdater：原子更新引用类型里的字段

AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference（V initialRef，booleaninitialMark）

AtomicReferenceFieldUpdater使用

如果需要原子更新某个对象的某个字段，就需要使用原子更新属性的相关类，atomic中提供了一下几个类用于原子更新属性：

　　AtomicIntegerFieldUpdater：原子更新整形属性的更新器

　　AtomicLongFieldUpdater：原子更新长整形的更新器

　　AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更新数据和数据的版本号，可以解决使用CAS进行原子更新时可能出现的ABA问题。

想要原子的更新字段，需要两个步骤

示例

Java不能直接访问操作系统底层，而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作

类中提供的3个本地方法allocateMemory、reallocateMemory、freeMemory分别用于分配内存，扩充内存和释放内存，与C语言中的3个方法对应。

public native long allocateMemory(long l);

public native long reallocateMemory(long l, long l1);

public native void freeMemory(long l);

JAVA中对象的字段的定位可能通过staticFieldOffset方法实现，该方法返回给定field的内存地址偏移量，这个值对于给定的filed是唯一的且是固定不变的。

getIntVolatile方法获取对象中offset偏移地址对应的整型field的值,支持volatile load语义

getLong方法获取对象中offset偏移地址对应的long型field的值

Unsafe类中有很多以BASE_OFFSET结尾的常量，比如ARRAY_INT_BASE_OFFSET，ARRAY_BYTE_BASE_OFFSET等，这些常量值是通过arrayBaseOffset方法得到的。arrayBaseOffset方法是一个本地方法，可以获取数组第一个元素的偏移地址。Unsafe类中还有很多以INDEX_SCALE结尾的常量，比如 ARRAY_INT_INDEX_SCALE ， ARRAY_BYTE_INDEX_SCALE等，这些常量值是通过arrayIndexScale方法得到的。arrayIndexScale方法也是一个本地方法，可以获取数组的转换因子，也就是数组中元素的增量地址。将arrayBaseOffset与arrayIndexScale配合使用，可以定位数组中每个元素在内存中的位置。

public final class Unsafe {
public static final int ARRAY_INT_BASE_OFFSET;
public static final int ARRAY_INT_INDEX_SCALE;

public native long staticFieldOffset(Field field);
public native int getIntVolatile(Object obj, long l);
public native long getLong(Object obj, long l);
public native int arrayBaseOffset(Class class1);
public native int arrayIndexScale(Class class1);
static
{
ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset([I);
ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale([I);
}
}

将一个线程进行挂起是通过park方法实现的，调用 park后，线程将一直阻塞直到超时或者中断等条件出现。unpark可以终止一个挂起的线程，使其恢复正常。整个并发框架中对线程的挂起操作被封装在 LockSupport类中，LockSupport类中有各种版本pack方法，但最终都调用了Unsafe.park()方法

是通过compareAndSwapXXX方法实现的

CAS操作有3个操作数，内存值M，预期值E，新值U，如果M==E，则将内存值修改为B，否则啥都不做。

allocateInstance()方法提供了另一种创建实例的途径。通常我们可以用new或者反射来实例化对象，使用allocateInstance()方法可以直接生成对象实例，且无需调用构造方法和其它初始化方法。

这在对象反序列化的时候会很有用，能够重建和设置final字段，而不需要调用构造方法。

这部分包括了monitorEnter、tryMonitorEnter、monitorExit、compareAndSwapInt、compareAndSwap等方法。

其中monitorEnter、tryMonitorEnter、monitorExit已经被标记为deprecated，不建议使用。

Unsafe类的CAS操作可能是用的最多的，它为Java的锁机制提供了一种新的解决办法，比如AtomicInteger等类都是通过该方法来实现的。compareAndSwap方法是原子的，可以避免繁重的锁机制，提高代码效率。这是一种乐观锁，通常认为在大部分情况下不出现竞态条件，如果操作失败，会不断重试直到成功。

读写分离，只对写做同步处理，不对读作同步处理，既保证了写的线程安全又保证了读的高性能。

如果没有CopyOnWrite机制，如果想要实现线程安全的ArrayList，无非有几种方式 :

Synchronzied：如果使用Synchronzied，相当于ArrayList同一时间只可以有一个线程可以访问，很显然效率较低；

ReentrantLock：和Synchronzied基本上一致同一时间只有一个线程访问

ReentrantReadWriteLock：读写锁一定程度上实现了读写分开加锁的操作，但是如果有一个线程占有了写锁，此时有大量的读请求时还是会同样被阻塞中，所以读写锁还是会有写锁阻塞读锁的情况

而CopyOnWrite思想是复制副本来进行修改，而读线程读的还是原数据，就不会出现写线程将读线程给阻塞的情况了。

CopyOnWriteArrayList内部存储数据的也是一个Object数组，只不过是volatile修饰的保证了多线程修改时内存可见性，而三个构造方法实现逻辑都是创建一个Object数组，然后直接赋值给CopyOnWriteArrayList内部的Object数组

从源码可以看出，保证add方法线程安全的方式是通过可重入锁ReentrantLock来实现的，执行插入之前进行加锁，插入完成之后解锁，所以插入的过程肯定是线程安全的。另外和ArrayList实现逻辑不同的是，ArrayList每次插入之前都会判断是否需要扩容，如果需要扩容的话会扩容1.5倍，而CopyOnWriteArrayList每次只扩容1位，扩容之后插入数据直接将复制的副本替换掉原数组，而不是直接在原数组上进行修改的。
正如CopyOnWrite机制所说的那样，写的时候先通过复制原数组，然后写入数据，最后再直接替换掉原数组。

从源码上流程上没什么大的问题，加锁->复制->修改->替换
但是有一段代码比较特殊，也就是第18行的setArray(elements), 当set的数据和旧的数据一致时，那么数组是并没有被修改的，理论上执行或不执行setArray这行代码效果是一样的，为什么还需要保留这一行代码呢？
注释的意思是为了确保volatile写的语义。
因为CopyOnWriteArrayList内部的数组对象array是通过volatile修饰的，而这里的setArray并不是为了保证array对于其他线程的可见性，而是为了保证外部非volatile变量的happen-before原则。？？？

可以看出CopyOnWriteArrayList读取数据的逻辑比较简单，就是从数组中获取指定index的数据，并且没有做同步处理，所以get操作和ArrayList的逻辑和效果是一模一样的。
但是由于get操作没有任何同步操作，所以理论上是会存在脏读的情况的，比如线程A写数据，在执行setArray之前，线程B读了数据，此时线程B读取的还是原数组中的数据，而实际上线程A已经对副本进行了修改操作了，只是还没有覆盖。同理的还有CopyOnWriteArrayList的size()、isEmpty()等读操作相关的方法都会存在类似的脏读问题。

1、CopyOnWriteArrayList是线程安全的List，底层数据结构也是数组结构，不过通过volatile修饰，使得写操作之后立即刷新内存，使得其他线程读最新的数据。是基于CopyOnWrite机制实现的线程安全的List
2、CopyOnWriteArrayList每次插入数据都会进行一次扩容，容量加1，并且在写之前都需要通过ReentrantLock加锁处理，然后复制原数组，写完数据之后直接覆盖原数组
3、CopyOnWriteArrayList的读操作没有加锁处理，所以会存在脏读问题，可能会读到其他线程以及修改，但是还没有替换原数组的数据
4、CopyOnWriteArrayList每次插入数据都会涉及到数组的复制，所以不适合频繁写而导致频繁复制数组的场景，而读没有加锁，所以适合写少读多的场景。
5、CopyOnWriteArrayList通过迭代器循环时，只可以循环读，而不可以执行写操作，因为迭代的数据是副本数据。
6、CopyOnWriteArrayList的set方法当设置数据一直时也同样会复制数组，不是为了保证数组的可见性，而是为了保证外部非volatile变量的happen-before关系，从而实现volatile的语义。

CopyOnWriteArraySet是一个线程安全的无序集合，相当于线程安全的HashSet，但是实现和HashSet完全不同，HashSet底层是通过HashMap来实现的，而CopyOnWriteArraySet底层则是通过CopyOnWriteArrayList来实现的，
CopyOnWriteArraySet 内部基本上所有的方法实现都是通过CopyOnWriteArrayList来实现的。

插入数据是调用CopyOnWriteArrayList的addIfAbsent方法，该方法的作用是如果插入的数据不存在就插入，否则就插入失败，这样的操作就实现了set中不会出现重复数据的要求。
可以看出实际就是遍历数组，是否包含待插入的数据，如果不包含则可以插入，否则直接返回false不允许插入。
类似的CopyOnWriteArraySet的所有方法基本上全是通过CopyOnWriteArrayList来实现的。相当于CopyOnWriteArraySet就是去重版本的CopyOnWriteArrayList。

CountDownLatch是一个同步辅助类，它允许一个或多个线程一直等待直到其他线程执行完毕才开始执行。

用给定的计数初始化CountDownLatch，其含义是要被等待执行完的线程个数。

每次调用CountDown()，计数减1

主程序执行到await()函数会阻塞等待线程的执行，直到计数为0

计数器通过使用锁（共享锁、排它锁）实现

CountDownLatch cd = new CountDownLatch(10);

cd.countDown();

cd.await();

初始值被减为0后，无法被重置

CyclicBarrier允许一组线程在到达某个栅栏点(common barrier point)互相等待，直到最后一个线程到达栅栏点，栅栏才会打开，处于阻塞状态的线程恢复继续执行。

CyclicBarrier cyclicBarrier = new CyclicBarrier(10)

对于CountDownLatch，其他线程为游戏玩家，比如英雄联盟，主线程为控制游戏开始的线程。在所有的玩家都准备好之前，主线程是处于等待状态的，也就是游戏不能开始。当所有的玩家准备好之后，下一步的动作实施者为主线程，即开始游戏。

对于CyclicBarrier，假设有一家公司要全体员工进行团建活动，活动内容为翻越三个障碍物，每一个人翻越障碍物所用的时间是不一样的。但是公司要求所有人在翻越当前障碍物之后再开始翻越下一个障碍物，也就是所有人翻越第一个障碍物之后，才开始翻越第二个，以此类推。类比地，每一个员工都是一个“其他线程”。当所有人都翻越的所有的障碍物之后，程序才结束。而主线程可能早就结束了，这里我们不用管主线程。

Classfile /Users/zejian/Downloads/Java8_Action/src/main/java/com/zejian/concurrencys/SyncMethod.class
Compiled from "SyncMethod.java"
public class com.zejian.concurrencys.SyncMethod

minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool;

//省略没必要的字节码
//==================syncTask方法======================
public synchronized void syncTask();
descriptor: ()V

//方法标识ACC_PUBLIC代表public修饰，ACC_SYNCHRONIZED指明该方法为同步方法
flags: ACC_PUBLIC, ACC_SYNCHRONIZED

Code:

stack=3, locals=1, args_size=1
0: aload_0
1: dup
2: getfield #2 // Field i:I
5: iconst_1
6: iadd
7: putfield #2 // Field i:I
10: return
LineNumberTable:
line 12: 0
line 13: 10
}

SourceFile: "SyncMethod.java"

从字节码中可以看出，synchronized修饰的方法并没有monitorenter指令和monitorexit指令，取得代之的确实是ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法，JVM通过该ACC_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

 //===========主要看看syncTask方法实现================
public void syncTask();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=3, locals=3, args_size=1
0: aload_0
1: dup
2: astore_1
3: monitorenter //注意此处，进入同步方法
......
21: monitorexit //注意此处，退出同步方法
22: aload_2
23: athrow
24: return
Exception table:
//省略其他字节码.......
}
SourceFile: "SyncCodeBlock.java"

1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）
6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

锁住的对象不同

线程 A 释放一个锁，实质上是线程 A 向接下来将要获取这个锁的某个线程发出了（线程 A 对共享变量所做修改的）消息。

线程 B 获取一个锁，实质上是线程 B 接收了之前某个线程发出的（在释放这个锁之前对共享变量所做修改的）消息。

线程 A 释放锁，随后线程 B 获取这个锁，这个过程实质上是线程 A 通过主内存向线程 B 发送消息。

AbstarctQueuedSynchronizer简称AQS，是一个用于构建锁和同步容器的框架。事实上concurrent包内许多类都是基于AQS构建的，例如ReentrantLock，Semphore，CountDownLatch，ReentrantReadWriteLock，FutureTask等。AQS解决了在实现同步容器时大量的细节问题

tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。
tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。
tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。
isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。

AQS需要子类复写的方法均没有声明为abstract，目的是避免子类需要强制性覆写多个方法，因为一般自定义同步器要么是独占方法，要么是共享方法，只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可
当然，AQS也支持子类同时实现独占和共享两种模式，如ReentrantReadWriteLock

acquire(int)

tryAcquire(arg)为线程获取资源的方法函数

acquire()方法至少执行一次tryAcquire(arg)，若返回true，则acquire直接返回，否则进入acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法

acquireQueued方法分为3个步骤

addWaiter(Node)

enq(node)

可以看到，常规插入与快速插入相比，有2点不同：

acquireQueued(Node, int)

shouldParkAfterFailedAcquire函数

parkAndCheckInterrupt()函数

至此，独占模式下，线程获取资源acquire的代码就跟完了，总结一下过程

其入口函数为

tryRelease(int)

unparkSuccessor(Node)

后继节点的阻塞线程被唤醒后，就进入到acquireQueued()的if (p == head && tryAcquire(arg))的判断中，此时被唤醒的线程将尝试获取资源。

当然，如果被唤醒的线程所在节点的前继节点不是头结点，经过shouldParkAfterFailedAcquire的调整，也会移动到等待队列的前面，直到其前继节点为头结点。

讲解完独占模式下资源的acquire/release过程，下面开始讲解共享模式下，线程如何完成资源的获取和共享。

方法入口
执行tryAcquireShared方法获取资源，若获取成功则直接返回，若失败，则进入等待队列，执行自旋获取资源，具体由doAcquireShared方法来实现

tryAcquireShared(int)

doAcquireShared(int)

doAcquireShared将线程的自我中断操作放在了方法体内部；
当线程获取到资源后，doAcquireShared会将当前线程所在的节点设为头结点，若资源有剩余则唤醒后续节点，比acquireQueued多了个唤醒后续节点的操作。

setHeadAndPropagate(Node, int)函数

可以看到，实际执行唤醒后继节点的方法是doReleaseShared()

方法入口

1.Exclusive：独占，只有一个线程能执行，如ReentrantLock

2.Share：共享，多个线程可以同时执行，如Semaphore、CountDownLatch、ReadWriteLock，CyclicBarrier

state初始化为0，表示未锁定状态，A线程lock()时，会调用tryAcquire()独占锁并将state+1.之后其他线程再想tryAcquire的时候就会失败，直到A线程unlock（）到state=0为止，其他线程才有机会获取该锁。A释放锁之前，自己也是可以重复获取此锁（state累加），这就是可重入的概念

状态列举

当线程调用了await方法以后。线程就作为队列中的一个节点被加入到等待队列中去了。同时会释放锁的拥有。当从await方法返回的时候。一定会获取condition相关联的锁。当等待队列中的节点被唤醒的时候，则唤醒节点的线程开始尝试获取同步状态。如果不是通过 其他线程调用Condition.signal()方法唤醒，而是对等待线程进行中断，则会抛出InterruptedException异常信息。

通过调用Condition.singal方法，将会唤醒在等待队列中等待时间最长的节点（首节点），在唤醒节点之前，会将节点移到同步队列中。

通过调用AQS的enq方法，等待队列的头结点线程安全的移动到同步队列。当节点移动到同步队列后，当前线程的状态如果处于取消或者被中断的状态，或者更新该节点的状态失败则会唤醒这个线程。

        被唤醒后的线程将从await方法的while循环中退出（isOnSyncQueue返回true，因为节点已经在同步队列中），进而调用AQS的acquireQueued方法加入到获取同步状态的竞争中。

        Condition的singalAll方法，相当于对等待队列的每个节点均执行一次singal方法，效果就是将等待队列中所有节点全部移动到同步队列，并唤醒每个节点的线程

调用await方法后，将当前线程加入Condition等待队列中。当前线程释放锁。否则别的线程就无法拿到锁而发生死锁。自旋(while)挂起，不断检测节点是否在同步队列中了，如果是则尝试获取锁，否则挂起。当线程被signal方法唤醒，被唤醒的线程将从await()方法中的while循环中退出来，然后调用acquireQueued()方法竞争同步状态

借助于Condition对象，RetrantLock可以实现类似于Object的wait和notify/notifyAll功能。使用它具有更好的灵活性。

在一个Lock对象里面可以创建多个Condition(对象监视器)实例，线程对象可以注册在指定的Condition对象中，从而可以有选择性的进行线程通知，实现多路通知功能，在调度线程上更加灵活。

在java中，对于任意一个java对象，它都拥有一组定义在java.lang.Object上监视器方法，包括wait()，wait(long timeout)，notify()，notifyAll()，这些方法配合synchronized关键字一起使用可以实现等待/通知模式