线程安全

线程安全性：

定义：当多个线程访问某个类时，不管允许时环境采用何种调度方式或者这些进程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这些类都能表现出正确的行为，那么就称为这个类是线程安全的.

• 原子性：提供互斥访问，同一时刻只能有一个线程来对它进行操作。
• 可见性：一个线程对主内存的修改可以及时的被其他线程观察到。
• 有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序的存在，该观察结果一般杂乱无序。

原子性

Atomic包

• AtomicXXX：CAS，Unsafe.compareAndSwapInt

  
  
  

  Atomic

    /**
     * Atomically increments by one the current value.
     *
     * @return the updated value
     */
    public final int incrementAndGet() {
        // 主要是调用了unsafe的方法 
        // private static final Unsafe unsafe = Unsafe.getUnsafe();
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

/**
  *  获取底层当前的值并且+1
  * @param var1 需要操作的AtomicInteger 对象
  * @param var2 当前的值 
  * @param var4 要增加的值
  */
  public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            // 获取底层的该对象当前的值
            var5 = this.getIntVolatile(var1, var2);
            // 获取完底层的值和自增操作之间，可能系统的值已经又被其他线程改变了
            //如果又被改变了，则重新计算系统底层的值，并重新执行本地方法
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
        return var5;
     }

/** 
  * 本地的CAS方法核心 
  * @param var1 需要操作的AtomicInteger 对象 
  * @param var2 当前本地变量中的的值 
  * @param var4 当前系统从底层传来的值 
  * @param var5 要更新后的值 
  * @Return 如果当前本地变量的值（var2）与底层的值(var4)不等，则返回false，否则更新为var5的值并返回True 
  */

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

• AtomicLong、LongAdder

LongAdder的设计思想：核心是将热点数据分离，将内部数据value分成一个数组，每个线程访问时，通过hash等算法映射到其中一个数字进行技术，而最终计数结果为这个数组的求和累加，其中热点数据value会被分离成多个热点单元的数据cell，每个cell独自维护内部的值，当前value的实际值由所有的cell累积合成，从而使热点进行了有效的分离，提高了并行度.
LongAdder 在低并发的时候通过直接操作base，可以很好的保证和Atomic的性能基本一致，在高并发的场景，通过热点分区来提高并行度

缺点：在统计的时候如果有并发更新，可能会导致结果有些误差

• AtomicReference、AtomicReferenceFieldUpdater

AtomicReference: 用法同AtomicInteger一样，但是可以放各种对象

package com.mmall.example.atomic;


import com.mmall.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.LongAdder;

/**
 * 线程安全的 --> AtomicReference
 * Created by megan on 2018/3/18.
 */
@Slf4j
@ThreadSafe
public class AtomicReferenceExample {
    private static AtomicReference count = new AtomicReference<>(0);

    public static void main(String[] args) {
        // 2
        count.compareAndSet(0,2);
        // no
        count.compareAndSet(0,1);
        // no
        count.compareAndSet(1,3);
        // 4
        count.compareAndSet(2,4);
        // no
        count.compareAndSet(3,5);
        log.info("count:{}",count);
    }

}

AtomicReferenceFieldUpdater:

package com.mmall.example.atomic;


import com.mmall.annoations.ThreadSafe;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

/**
 * 线程安全的 --> AtomicReferenceFieldUpdater
 * Created by megan on 2018/3/18.
 */
@Slf4j
@ThreadSafe
public class AtomicReferenceFieldUpdaterExample {

    private static AtomicIntegerFieldUpdater updater =
            AtomicIntegerFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterExample.class, "count");

    @Getter
    private volatile int count = 100;


    public static void main(String[] args) {

        AtomicReferenceFieldUpdaterExample example =  new AtomicReferenceFieldUpdaterExample();

        if(updater.compareAndSet(example,100,200)){
            log.info("update success 1 , {}",example.getCount());
        }

        if(updater.compareAndSet(example,100,200)){
            log.info("update success 2 , {}",example.getCount());
        }else{
            log.info("update failed ,{}",example.getCount());
        }
    }

}

• AtomicStampReference:CAS的ABA问题

ABA问题：在CAS操作的时候，其他线程将变量的值A改成了B由改成了A，本线程使用期望值A与当前变量进行比较的时候，发现A变量没有变，于是CAS就将A值进行了交换操作，这个时候实际上A值已经被其他线程改变过，这与设计思想是不符合的

解决思路：每次变量更新的时候，把变量的版本号加一，这样只要变量被某一个线程修改过，该变量版本号就会发生递增操作，从而解决了ABA变化

• AtomicBoolean

package com.mmall.example.atomic;


import com.mmall.annoations.ThreadSafe;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

/**
 * 线程安全的 --> AtomicBoolean
 * 5000次请求，test方法只执行一次
 * Created by megan on 2018/3/18.
 */
@Slf4j
@ThreadSafe
public class AtomicBooleanExample {

    private static AtomicBoolean isHappened  =  new AtomicBoolean(false);

    /** 请求数 **/
    public static int clientTotal = 5000;

    /** 同时并发执行线程数 **/
    public static int threadTotal = 200;

    public static void main(String[] args) throws Exception {
        //定义一个线程池
        ExecutorService executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                60L, TimeUnit.SECONDS,
                new SynchronousQueue<>(), r -> new Thread(r,"测试线程AtomicBoolean"));
        // 信号量，闭锁
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        // 模拟并发请求
        for(int i = 0; i < clientTotal; i ++){
            executorService.execute(() -> {
                try {
                    // 请求一个信号，如果信号量小于clientTotal，则阻塞
                    semaphore.acquire();
                    test();
                    // 释放一个信号
                    semaphore.release();
                } catch (InterruptedException e) {
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        // 阻塞直到countDown 的次数为threadTotal
        countDownLatch.await();
        // 关闭线程池
        executorService.shutdown();
        log.info("isHappened:{}",isHappened);
    }

    private static void test(){
        if(isHappened.compareAndSet(false,true)){
            log.info("execute");
        }
    }

}

原子性-锁

• synchronized：依赖JVM （主要依赖JVM实现锁，因此在这个关键字作用对象的作用范围内，都是同一时刻只能有一个线程进行操作的）

1、修饰代码块：大括号括起来的代码，作用于调用的对象
2、修饰方法，作用于调用的对象
3、修饰静态方法：整个静态方法，作用于所有对象
4、修饰类：括号包起来的部分，作用于所有对象

package com.mmall.example.sync;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;

/**
 * Synchronized 锁
 * Created by megan on 2018/3/21.
 */
@Slf4j
public class SynchronizedExample1 {

    /**
     * 修饰代码块,作用范围为大括号括起来的
     */
    public void test1(int j){
        synchronized (this){
            for(int i = 0,b = 10; i {}",j,i);
            }
        }
    }

    /**
     * 修饰整个方法，作用范围是整个方法，作用对象为调用这个方法的对象
     * 若子类继承父类调用父类的synchronized方法，是带不上synchronized关键字的
     * 原因：synchronized 不属于方法声明的一部分
     * 如果子类也想使用同步需要在方法上声明
     */
    public synchronized void test2(int j){
        for(int i = 0,b = 10; i {}",j,i);
        }
    }

    public static void main(String[] args) {
        SynchronizedExample1 example1 = new SynchronizedExample1();
        SynchronizedExample1 example2 = new SynchronizedExample1();
        //声明一个线程池
        ExecutorService executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                60L, TimeUnit.SECONDS,
                new SynchronousQueue<>(), r -> new Thread(r,"测试线程(Synchronized1)"));
        executorService.execute(() -> {
            example1.test2(1);
        });
        executorService.execute(() -> {
            example2.test2(2);
        });
    }
}

package com.mmall.example.sync;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Synchronized 锁
 * Created by megan on 2018/3/21.
 */
@Slf4j
public class SynchronizedExample2 {

    /**
     * 修饰类
     * 作用对象为这个类的所有对象
     */
    public static void test1(int j){
        synchronized (SynchronizedExample2.class){
            for(int i = 0,b = 10; i {}",j,i);
            }
        }
    }

    /**
     * 修饰静态方法
     * 作用对象为这个类的所有对象
     */
    public static synchronized void test2(int j){
        for(int i = 0,b = 10; i {}",j,i);
        }
    }

    public static void main(String[] args) {
        //声明一个线程池
        ExecutorService executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                60L, TimeUnit.SECONDS,
                new SynchronousQueue<>(), r -> new Thread(r,"测试线程(Synchronized1)"));
        executorService.execute(() -> {
            test2(1);
        });
        executorService.execute(() -> {
            test2(2);
        });
    }
}

• Lock：依赖特殊的CPU指令，代码实现，ReentrantLock

对比：

• synchronized:不可中断，适合竞争不激烈，可读性号
• Lock：可中断，多样化同步，竞争激烈是能维持常态
• Atomic：竞争激烈时能维持常态，比lock性能好；只能同步一个值。

---

可见性（java提供了synchronized和volatile 两种方法来确保可见性）

导致线程共享变量在线程间不可见的原因：

• 线程交叉执行
• 重排序结合线程交叉执行
• 共享变量更新后的值没有在工作内存与主内存间及时更新

JMM关于synchronized的两条规定：

• 线程解锁前，必须把共享变量的最小值刷新到主内存中
• 线程加锁是，将清空工作内存中共享变量的值，从而使共享变量时需要从主内存中重新读取最新的值（注意，加锁与解锁是同一把锁）

volatile

通过加入内存屏障和禁止重排序优化来实现可见性。

• 对于volatile变量写操作时，会在写操作后加入一条store屏障指令，将本地内存中的共享变量值刷新到主内存。

• 对volatile变量度操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量。

  
  
  

  volatile写操作时
  
  
  

  volatile读操作时
  
  

  volatile使用条件:
  1、对变量写操作不依赖于当前值
  2、该变量没有包含在具有其他变量的不必要的式子中

综上，volatile特别适合用来做线程标记量，如下图

volatile使用

---

有序性

java内存模型中，允许编译器和处理器对指令进行重排序，但是，重排序过程刽影响到单线程的执行，却会影响到多线程并发执行的正确性。

• volatile、synchronized、lock

happens-before原则

• 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作。
• 锁定规则： 一个unLock操作先行发生于后面对同一个锁的lock操作。
• volatile变量规则：对一个变量的写操作先行发生于后面对于这个变量的读操作。
• 传递规则： 对于操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C。
• 线程启动规则： Thread对于start()方法先行发生于此线程的每个动作。
• 线程中断规则： 对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生。
• 线程终结规则： 线程中所有的操作都先行发生于线程的终止检测，我们可以通过Tread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
• 对象终结原则： 一个对象的初始化完成先行发生于他的finalize()方法的开始.