线程安全性：
定义：当多个线程访问某个类时，不管允许时环境采用何种调度方式或者这些进程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这些类都能表现出正确的行为，那么就称为这个类是线程安全的.
- 原子性：提供互斥访问，同一时刻只能有一个线程来对它进行操作。
- 可见性：一个线程对主内存的修改可以及时的被其他线程观察到。
- 有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序的存在，该观察结果一般杂乱无序。
原子性
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<Integer> 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<AtomicReferenceFieldUpdaterExample> 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<b ; i++){
log.info("test1 {} --> {}",j,i);
}
}
}
/**
* 修饰整个方法，作用范围是整个方法，作用对象为调用这个方法的对象
* 若子类继承父类调用父类的synchronized方法，是带不上synchronized关键字的
* 原因：synchronized 不属于方法声明的一部分
* 如果子类也想使用同步需要在方法上声明
*/
public synchronized void test2(int j){
for(int i = 0,b = 10; i<b ; i++){
log.info("test2 {} --> {}",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<b ; i++){
log.info("test1 {} --> {}",j,i);
}
}
}
/**
* 修饰静态方法
* 作用对象为这个类的所有对象
*/
public static synchronized void test2(int j){
for(int i = 0,b = 10; i<b ; i++){
log.info("test2 {} --> {}",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()方法的开始.
