JUC - JUC 1 - 《JavaSE》

1 Java JUC简介
2 volatile 关键字-内存可见性
- 2.1 内存可见性
3 原子变量与CAS算法
4 CopyOnWriteArrayList
- CopyOnWriteArrayList 读取和写入源码简单分析
5 ConcurrentHashMap
6 CountDownLatch(闭锁)
- 5.1 概念
- 5.2 方法介绍
7 CyclicBarrier
8 Semaphore
9 BlockingQueue

javajavase

1 Java JUC简介

在 Java 5.0 提供了 java.util.concurrent (简称 JUC )包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步 IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的 Collection 实现等

2 volatile 关键字-内存可见性

2.1 内存可见性

Java 内存模型规定，对于多个线程共享的变量，存储在主内存当中，每个线程都有自己独立的工作内存，并且线程只能访问自己的工作内存，不可以访问其它线程的工作内存。工作内存中保存了主内存中共享变量的副本，线程要操作这些共享变量，只能通过操作工作内存中的副本来实现，操作完毕之后再同步回到主内存当中，其 JVM 模型大致如下图

JVM 模型规定

线程对共享变量的所有操作必须在自己的内存中进行，不能直接从主内存中读写;
不同线程之间无法直接访问其它线程工作内存中的变量，线程间变量值的传递需要通过主内存来完成

这样的规定可能导致得到后果是：

线程对共享变量的修改没有即时更新到主内存，或者线程没能够即时将共享变量的最新值同步到工作内存中，从而使得线程在使用共享变量的值时，该值并不是最新的。这就引出了内存可见性。

内存可见性(Memory Visibility)

是指当某个线程正在使用对象状态，而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。

可见性错误

是指当读操作与写操作在不同的线程中执行时，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情 ```java class ThreadDemo implements Runnable { private boolean flag = false; // 加volatile关键字修饰可解决

@Override public void run() {
```
  try {
      Thread.sleep(200);
  } catch (InterruptedException e) {
  }
  flag = true;
  System.out.println("flag=" + isFlag());
```
}

public boolean isFlag() {
```
  return flag;
```
} }

public class TestVolatile { public static void main(String[] args) { new Thread(new ThreadDemo()).start();

    while (true) {
        // 包个同步锁可以解决内存可见性问题
        if (td.isFlag()) {
            System.out.println("------------------");
            break;
        }    //    补个else{}稍微延迟一会也可以解决
    }
}

}

<a name="db14291d"></a>
### 2.2 volatile 关键字
Java 提供了一种稍弱的同步机制，即 volatile 变量，用来确保将变量的更新操作通知到其它线程。
- 当把共享变量声明为 volatile 类型后，**线程对该变量修改时会将该变量的值立即刷新回主内存，同时会使其它线程中缓存的该变量无效，**从而其它线程在读取该值时会从主内中重新读取该值（参考缓存一致性）。因此在读取 volatile 类型的变量时总是会返回最新写入的值
volatile**屏蔽掉了JVM中必要的代码优化(指令重排序)**，所以在效率上比较低，屏蔽的是通过CPU在volatile 修饰的类型前后加上fence原语，loadfence，禁止两句连读调换顺序，storefence禁止两句写调换顺序
```java
// 如果设置为    
private volatile boolean flag = false;
// 输出结果：
flag=true
------------------

volatile关键字最主要的作用是

保证变量的内存可见性
局部阻止重排序的发生

可以将 volatile 看做一个轻量级的锁，但是又与锁有些不同

对于多线程，不是一种互斥关系
不能保证变量状态的“原子性操作”

3 原子变量与CAS算法

3.1 原子变量

3.1.1 i++的原子性问题

/*
 * 一、i++ 的原子性问题：i++ 的操作实际上分为三个步骤“读-改-写”
 *           int i = 10;
 *           i = i++; //10
 * 
 *           int temp = i;
 *           i = i + 1;
 *           i = temp;
 * 
 * 二、原子变量：在 java.util.concurrent.atomic 包下提供了一些原子变量。
 *         1. volatile 保证内存可见性
 *         2. CAS（Compare-And-Swap） 算法保证数据变量的原子性
 *             CAS 算法是硬件对于并发操作的支持
 *             CAS 包含了三个操作数：
 *             ①内存值  V
 *             ②预估值  A
 *             ③更新值  B
 *             当且仅当 V == A 时， V = B; 否则，不会执行任何操作。
 */
class AtomicDemo implements Runnable{
    private volatile int serialNumber = 0;
//    private AtomicInteger serialNumber = new AtomicInteger(0);
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
        System.out.print(getSerialNumber()+" ");
    }
    public int getSerialNumber(){
        return serialNumber++;
//        return serialNumber.getAndIncrement();
    }
}
public class TestAtomicDemo {
    public static void main(String[] args) {
        AtomicDemo ad = new AtomicDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(ad).start();
        }
    }
}
// 运行结果：
// 0 4 3 2 1 0 5 6 7 8 ——> 会产生重复

// 如果改为：
class AtomicDemo implements Runnable{
//    private volatile int serialNumber = 0;
    private AtomicInteger serialNumber = new AtomicInteger(0);
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
        System.out.print(getSerialNumber()+" ");
    }
    public int getSerialNumber(){
        return serialNumber.getAndIncrement();
    }
}
//运行结果
//1 3 2 0 4 6 5 7 8 9 ——> 不会重复

3.1.2 原子变量

实现全局自增id最简单有效的方式是什么？
java.util.concurrent.atomic包定义了一些常见类型的原子变量。这些原子变量为我们提供了一种操作单一变量无锁(lock-free)的线程安全(thread-safe)方式。实际上该包下面的类为我们提供了类似volatile变量的特性，同时还提供了诸如**boolean compareAndSet(expectedValue, updateValue)**的功能。
不使用锁实现线程安全听起来似乎很不可思议，这其实是通过CPU的compare and swap指令实现的，由于硬件指令支持当然不需要加锁了。

核心方法：boolean compareAndSet(expectedValue, updateValue)

原子变量类的命名类似于AtomicXxx，例如，AtomicInteger类用于表示一个int变量
标量原子变量类
AtomicInteger，AtomicLong和AtomicBoolean类分别支持对原始数据类型int，long和boolean的操作。
当引用变量需要以原子方式更新时，AtomicReference类用于处理引用数据类型
原子数组类
有三个类称为AtomicIntegerArray，AtomicLongArray和AtomicReferenceArray，它们表示一个int，long和引用类型的数组，其元素可以进行原子性更新

3.2 CAS算法
Compare And Swap (Compare And Exchange) / 自旋 / 自旋锁 / 无锁
CAS 是一种硬件对并发的支持，针对多处理器操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并发访问。
CAS 是一种无锁的非阻塞算法的实现。
CAS 包含了 3 个操作数：
- 需要读写的内存值 V
- 进行比较的值 A
- 拟写入的新值 B

当且仅当 V 的值等于 A 时，CAS 通过原子方式用新值 B 来更新 V的值，否则不会执行任何操作。

// 模拟 CAS 算法
public class TestCompareAndSwap {
    public static void main(String[] args) {
        final CompareAndSwap cas = new CompareAndSwap();    
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int expectedValue = cas.get();
                    boolean b = cas.compareAndSet(expectedValue, 
                                                  (int)(Math.random() * 101));
                    System.out.println(b);
                }
            }).start();
        }
    }
}
class CompareAndSwap{
    private int value;
    // 获取内存值
    public synchronized int get(){
        return value;
    }
    // 比较
    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        int oldValue = value;    
        if(oldValue == expectedValue){
            this.value = newValue;
        }    
        return oldValue;
    }
    //设置
    public synchronized boolean compareAndSet(int expectedValue, int newValue) {
        return expectedValue == compareAndSwap(expectedValue, newValue);
    }
}

3.2.1 ABA问题

CAS会导致ABA问题，线程1准备用CAS将变量的值由A替换为B，在此之前，线程2将变量的值由A替换为C，又由C替换为A，然后线程1执行CAS时发现变量的值仍然为A，所以CAS成功。但实际上这时的现场已经和最初不同了，尽管CAS成功，但可能存在潜藏的问题。
解决办法（版本号 AtomicStampedReference）

基础类型简单值不受影响

引用类型加版本号，被指向的A内部属性可能变化，而指向A的引用没有变

3.2.2 CAS在JAVA中底层的实现

Unsafe
Unsafe类：Java 与 C/C++ 的一个非常明显区别就是，Java 中不可以直接操作内存。当然这并不完全正确，因为 Unsafe 就可以做到。
Unsafe在AtomicInteger中的应用

class AtomicDemo implements Runnable {
  private AtomicInteger serialNumber = new AtomicInteger(0);
  @Override
  public void run() {
      try {
          Thread.sleep(200);
      } catch (InterruptedException e) {
      }
      System.out.print(getSerialNumber() + " ");
  }
  public int getSerialNumber(){
      return serialNumber.incrementAndGet();
  }
}

```java public final int incrementAndGet() {

  for (;;) {
      int current = get();
      int next = current + 1;
      if (compareAndSet(current, next))
          return next;
  }

}

public final boolean compareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); }

Unsafe
```java
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

运用

package com.mashibing.jol;
import sun.misc.Unsafe;
import java.lang.reflect.Field;
public class T02_TestUnsafe {
    int i = 0;
    private static T02_TestUnsafe t = new T02_TestUnsafe();
    public static void main(String[] args) throws Exception {
        //Unsafe unsafe = Unsafe.getUnsafe();
        Field unsafeField = Unsafe.class.getDeclaredFields()[0];
        unsafeField.setAccessible(true);
        Unsafe unsafe = (Unsafe) unsafeField.get(null);
        Field f = T02_TestUnsafe.class.getDeclaredField("i");
        long offset = unsafe.objectFieldOffset(f);
        System.out.println(offset);
        boolean success = unsafe.compareAndSwapInt(t, offset, 0, 1);
        System.out.println(success);
        System.out.println(t.i);
        //unsafe.compareAndSwapInt()
    }
}

jdk8u: unsafe.cpp
cmpxchg = compare and exchange

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj);
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

jdk8u: atomic_linux_x86.inline.hpp
is_MP = Multi Processor

inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  int mp = os::is_MP();
  __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
                    : "=a" (exchange_value)
                    : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                    : "cc", "memory");
  return exchange_value;
}

jdk8u: os.hpp is_MP()

  static inline bool is_MP() {
    // During bootstrap if _processor_count is not yet initialized
    // we claim to be MP as that is safest. If any platform has a
    // stub generator that might be triggered in this phase and for
    // which being declared MP when in fact not, is a problem - then
    // the bootstrap routine for the stub generator needs to check
    // the processor count directly and leave the bootstrap routine
    // in place until called after initialization has ocurred.
    return (_processor_count != 1) || AssumeMP;
  }

jdk8u: atomic_linux_x86.inline.hpp

#define LOCK_IF_MP(mp) "cmp $0, " #mp "; je 1f; lock; 1: "

最终实现
cmpxchg = cas修改变量值

lock cmpxchg 指令   //记住这条指令

cmpxchg不能保证原子性，lock保证了原子性（当执行cmpxchg指令时，其他CPU不允许对里面的值进行修改）
硬件
lock指令在执行后面指令的时候锁定一个北桥信号（电信号）
（不采用锁总线的方式）

CAS在JAVA中底层的实现是通过 lock cmpxchg来实现的 volatile和synchronized的实现也都跟这条指令有关

3.3 原子性与可见性区别

4 CopyOnWriteArrayList

CopyOnWriteArrayList 类的所有可变操作（add，set等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，并不直接修改原有数组对象，而是对原有数据进行一次拷贝，将修改的内容写入副本中。写完之后，再将修改完的副本替换成原来的数据，这样就可以保证写操作不会影响读操作了。

从 CopyOnWriteArrayList 的名字可以看出，CopyOnWriteArrayList 是满足 CopyOnWrite 的 ArrayList，所谓 CopyOnWrite 的意思：、就是对一块内存进行修改时，不直接在原有内存块中进行写操作，而是将内存拷贝一份，在新的内存中进行写操作，写完之后，再将原来指向的内存指针指到新的内存，原来的内存就可以被回收。

CopyOnWriteArrayList 读取和写入源码简单分析

CopyOnWriteArrayList 读取操作的实现

读取操作没有任何同步控制和锁操作，理由就是内部数组 array 不会发生修改，只会被另外一个 array 替换，因此可以保证数据安全。

/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;
public E get(int index) {
    return get(getArray(), index);
}
@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
    return (E) a[index];
}
final Object[] getArray() {
    return array;
}

CopyOnWriteArrayList 写入操作的实现

CopyOnWriteArrayList 写入操作 add() 方法在添加集合的时候加了锁，保证同步，避免多线程写的时候会 copy 出多个副本。

    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();  // 加锁
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);  // 拷贝新数组
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();  // 释放锁
        }
    }

5 ConcurrentHashMap

ConcurrentHashMap 同步容器类是Java 5 增加的一个线程安全的哈希表。对于多线程的操作，介于 HashMap 与 Hashtable 之间。内部采用“锁分段” 机制替代 Hashtable 的独占锁，进而提高性能

1 锁粒度

减小锁粒度是指缩小锁定对象的范围，从而减小锁冲突的可能性，从而提高系统的并发能力。减小锁粒度是一种削弱多线程锁竞争的有效手段，这种技术典型的应用是 ConcurrentHashMap(高性能的HashMap)类的实现。对于 HashMap 而言，最重要的两个方法是 get 与 set 方法，如果我们对整个 HashMap 加锁，可以得到线程安全的对象，但是加锁粒度太大。Segment 的大小也被称为 ConcurrentHashMap 的并发度

2 锁分段

ConcurrentHashMap，它内部细分了若干个小的 HashMap，称之为段(Segment)
默认情况下一个 ConcurrentHashMap 被进一步细分为 16 个段，既就是锁的并发度
如果需要在 ConcurrentHashMap 中添加一个新的表项，并不是将整个 HashMap 加锁，而是首先根据 hashcode 得到该表项应该存放在哪个段中，然后对该段加锁，并完成 put 操作。在多线程环境中，如果多个线程同时进行put操作，只要被加入的表项不存放在同一个段中，则线程间可以做到真正的并行

注：上为 JDK1.7 中 ConcurrentHashMap 的实现方式，而到了JDK1.8改为和HashMap结构类似，只是加了volatile CAS synchronize

3 其它

此包还提供了设计用于多线程上下文中的 Collection 实现
ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、 CopyOnWriteArrayList 和 CopyOnWriteArraySet

当期望许多线程访问一个给定 collection 时，ConcurrentHashMap 通常优于同步的 HashMap， ConcurrentSkipListMap 通常优于同步的 TreeMap（第一，它们的线程安全机制不同，TreeMap是非线程安全的，而ConcurrentSkipListMap是线程安全的。第二，ConcurrentSkipListMap是通过跳表实现的，而TreeMap是通过红黑树实现的）
当期望的读数和遍历远远大于列表的更新数时，CopyOnWriteArrayList 优于同步的 ArrayList。
4 写入并复制
注意：添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大。并发迭代操作多时可以选择 ```java public class TestCopyOnWriteArrayList { public static void main(String[] args) {
```
  HelloThread ht = new HelloThread();    
  for (int i = 0; i < 10; i++) {
      new Thread(ht).start();
  }
```
} }

class HelloThread implements Runnable{ private static List list = Collections.synchronizedList(new ArrayList()); // private static CopyOnWriteArrayList list = new CopyOnWriteArrayList<>(); static{ list.add(“AA”); list.add(“BB”); list.add(“CC”); }

@Override
public void run() {
    Iterator<String> it = list.iterator();        
    while(it.hasNext()){
        System.out.println(it.next());
        list.add("AA");
    }
}

}

运行会造成并发修改异常**ConcurrentModificationException**。遍历的列表和添加的都是同一个
```java
//private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

这样不会报错，正常运行。因为在每次写入时，都会在底层完成一次复制，复制一份新的列表，然后再进行添加。每次写入都会复制。不会造成并发修改异常，但是效率较低。
添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大。并发迭代操作多时可以选择

6 CountDownLatch(闭锁)

5.1 概念

CountDownLatch（闭锁）——一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。CountDown（倒数）latch（锁）
用给定的计数初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。 一个线程(或者多个)，等待另外N个线程完成某个事情之后才能执行。
闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行

确保某个计算在其需要的所有资源都被初始化之后才继续执行;
确保某个服务在其依赖的所有其他服务都已经启动之后才启动;
等待直到某个操作所有参与者都准备就绪再继续执行。

5.2 方法介绍
CountDownLatch最重要的方法是**countDown()**——倒数和 **await()**，前者主要是倒数一次，后者是等待倒数到0，如果没有到达0，就只有阻塞等待了 ```java // 统计50个线程执行的时间，必须等50个线程执行完了才能计时，这就用到闭锁 class LatchDemo implements Runnable { private CountDownLatch latch;

public LatchDemo(CountDownLatch latch) {
```
  this.latch = latch;
```
}

@Override public void run() {
```
  try {
      for (int i = 0; i < 50000; i++) {
          if (i % 2 == 0) {
              System.out.println(i);
          }
      }
  } finally {
      latch.countDown();    // 每次执行完-1，放在finally里确保每次都执行
  }
```
} }

public class TestCountDownLatch {

public static void main(String[] args) {
    // 每次有个线程执行完-1，设置初始值50
    final CountDownLatch latch = new CountDownLatch(50);
    LatchDemo ld = new LatchDemo(latch);
    long start = System.currentTimeMillis();      
    for (int i = 0; i < 50; i++) {
        new Thread(ld).start();
    }
    try {
        latch.await();   // 50个线程执行完，才继续执行main线程
    } catch (InterruptedException e) {
    }   
    long end = System.currentTimeMillis();
    System.out.println("耗费时间为：" + (end - start));
}

} ```

7 CyclicBarrier

集齐七颗龙珠才能召唤神龙

8 Semaphore

争车位秒杀

9 BlockingQueue

ArrayBlockingQueue

数组构成的有界阻塞队列

LinkedBlockingDeque

链表构成的有界阻塞队列，但界是Integer.MAX_VALUE

SynchronousQueue

不存储元素的阻塞队列，即单元素阻塞队列

DelayQueue

使用优先级队列实现的无界阻塞队列

PriorityBlockingQueue

支持优先级的无界阻塞队列

LinkedTransferQueue

链表构成的无界阻塞队列

LinkedBlockingDeque

链表构成的双向无界阻塞队列

JUC 1

1 Java JUC简介

2 volatile 关键字-内存可见性

2.1 内存可见性

3 原子变量与CAS算法

3.1 原子变量

3.1.1 i++的原子性问题

3.1.2 原子变量

3.2 CAS算法

3.2.1 ABA问题

3.2.2 CAS在JAVA中底层的实现

3.3 原子性与可见性区别

4 CopyOnWriteArrayList

CopyOnWriteArrayList 读取和写入源码简单分析

5 ConcurrentHashMap

1 锁粒度

2 锁分段

3 其它

4 写入并复制

6 CountDownLatch(闭锁)

5.1 概念

5.2 方法介绍

7 CyclicBarrier

8 Semaphore

9 BlockingQueue

ArrayBlockingQueue

LinkedBlockingDeque

SynchronousQueue

DelayQueue

PriorityBlockingQueue

LinkedTransferQueue

LinkedBlockingDeque