如何理解线程安全
当多个线程访问某个对象时候，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的
1 线程安全问题的本质
产生原因，cpu，内存，io的读写速率不同，cpu>内存>io
计算机通过建立高速缓存区提高了效率
优化成果：
1.cpu增加了告诉缓存，均衡与内存的速度差异
2.操作系统增加进程，线程，以及分时复用cpu，均衡cpu与i/o设备的差异
3.编译程序优化指令的执行顺序，使得能够更加合理的利用缓存
原子性
1.1原子性问题的根源
进程切换造成
实例：
public class AtomicTest {
public static int i = 0;
public static void inc() throws InterruptedException {
Thread.sleep(1);
i++;
}
public static void main(String[] args) throws InterruptedException {
for (int i1 = 0; i1 < 1000; i1++) {
new Thread(()->{
try {
AtomicTest.inc();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
//休眠4秒的原因为了让子线程执行完
Thread.sleep(4000);
System.out.println(i);
}
}
执行结果
959
执行结果始终小于等于1000，分析如下：
通过打开AtomicTest.class字节码执行javap -v AtomicTest.class查看字节码执行如下
javap -v AtomicTest.class
可见性
1.2可见性问题的源头
如图：线程a,b同时操作变量x，对于cpu1操作的变量x放在cpu1的告诉缓存区中，对于cpu2是不可见的，每个cpu拥有自己的高速缓存区，私有的
实例：
public class XianchengTest {
public static boolean flag = false;
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
int i = 0;
while (!flag){
i++;
}
System.out.println(i);
});
thread.start();
System.out.println("thread start");
Thread.sleep(1000);
flag = true;
}
}
运行结果
thread start
分析：我们开启了一个线程，尝试在主线程中修改flag的值，使开启的新的线程结束循环，但是在主线程修改值之后，发现循环仍然在继续，说明主线程中修改的flag的值在子线程中不生效
有序性
1.3有序性问题的根源
实例：
期望执行顺序，A1,A2,B1,B2, 实际执行顺序 A2,A1,B2,B1
2 JAVA内存模型
2.1什么是JMM
java内存模型是一种抽象结构，它提供了合理的禁用缓存以及禁止重排序的方法来解决可见性，有序性问题
应用场景
JMM的抽象模型
JMM和硬件模型的对应简图
2.2可见性，有序性的解决方案
volatile,synchronized,final关键字
Happen-Before原则
3 同步关键字synchronized
3.1 synchronized的作用
可以解决可见性，原子性，有序性问题
synchronized锁的范围
对于普通同步方法，锁是当前实例对象
对于静态同步方法，锁是当前类的class对象
对于同步方法块，锁是synchronized括号里配置的对象
实例：
public class SynchronizedTest {
//对象锁
public synchronized void test1(){}
//类锁
public static synchronized void test2(){}
public static void main(String[] args) {
SynchronizedTest test1 = new SynchronizedTest();
SynchronizedTest test2 = new SynchronizedTest();
//这里开启两个线程，不会存在互斥现象，因为synchronized加载普通方法上
new Thread(()->{
test1.test1();
}).start();
new Thread(()->{
test2.test1();
}).start();
//如果要实现互斥，必须采用同一个对象调用
new Thread(()->{
test1.test1();
}).start();
new Thread(()->{
test1.test1();
}).start();
//当锁加在static静态方法上，这里不管是否使用同一个对象，都能实现互斥关系，因为是类锁
new Thread(()->{
test1.test2();
}).start();
new Thread(()->{
test2.test2();
}).start();
}
public void test3(){
//这里的this，可以用SynchronizedTest test1 = new SynchronizedTest();替换表示对象所
//也可以使用SynchronizedTest.class对象替换表示类锁
synchronized (this){
}
}
}
执行上面程序，观察生成的字节码文件判断
使用
javap -v SynchronizedTest.class
3.2 synchronized的本质
线程A执行monitorenter，获得监视器，这时，其他来获取监视器的线程进入同步队列，当线程a，执行monitorexit退出监视器，同步队列通知其他线程抢占监视器，继续进行如上操作
在jdk1.6之后引入如下优化
3.2 synchronized的优化
自适应锁自旋锁
引入偏向锁，轻量级锁
锁消除，锁粗化
4 volatile关键字分析
4.1 volatile可以用来解决可见性和有序性问题
实例：在上面的代码中加入volatile关键字
public class XianchengTest {
//volatile可以解决可见性和有序性问题
public static volatile boolean flag = false;
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
int i = 0;
while (!flag){
i++;
}
System.out.println(i);
});
thread.start();
System.out.println("thread start");
Thread.sleep(1000);
flag = true;
}
}
运行结果如下：
在加了volatile关键字之后，执行该代码时会产生一个lock指令
##lock指令的作用：
将当前处理器缓存行的数据写回到系统内存
这个写回内存的操作会使在其他cpu里缓存了该内存地址的数据无效
当存在多个线程对同一个共享变量进行修改的时候，需要增加volatile保证数据修改的实时可见
CPU层面的内存屏障
store Barrier:强制所有在store屏障指令之前的store指令，都在改store屏障指令执行之前被执行，并把store缓冲区的数据都刷到cpu缓存
Load Barrier：强制所有在load屏障指令之后的load指令，都在改load屏障指令执行之后被执行，并且一直等到load缓冲区被该cpu读完之后才能执行之后的load指令
Full Barrier：复合了load和stroe屏障的功能
不同的平台，硬件层面封装了不同的内存屏障指令，jvm虚拟机平台提供了如下的内存屏障指令
volatile总结
而#Lock指令本质上是禁止高速缓存解决可见性问题，但是实际上这里表示一种jvm提供的内存屏障的功能，针对当前硬件环境，jmm层面采用lock指令作为内存屏障来解决可见性问题
4.2 final域
final关键字：在java中是一个保留的关键字，可以声明成员变量，方法，类以及本地变量，一旦你将引用变量声明为final，你将不能改变这个引用了
final域和线程安全的关系
对于final域，编译器和处理器要遵循两个重排序规则
在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序
初次读一个包含final域的对象的引用，与随后初次读这个final域，这两个操作之间不能重排序
注：final关键字修饰的代码，不会存在指令重排序问题
实例：
可能执行的情况分析
写final域重排序规则
jmm禁止编译器把final域的写重排序到构造函数之外
编译器会在final域的写之后，构造函数return之前，插入一个StoreStore屏障，这个屏障禁止处理器把final域的写重排序到构造函数之外
读域的重排序规则
在一个线程中，初次读对象引用于初次读该对象包含的final域，jmm禁止处理器重排序这两个操作，编译器会在读final域操作的前面插入一个LoadLoad屏障
可能存在的执行情况
溢出带来的重排序问题
可能出现的情况
4.3 Happens-Before模型
什么是happens-before
happens-before是一种可见性规则，它表达的含义是前面一个操作的结果对后续操作是可见的
6中happens-before规则（天生满足可见性规则，不需要考虑可见性问题）
程序顺序规则：对于单线程程序顺序执行，不需要指令重排序
监视器锁规则：
volatile变量规则
传递性
start()规则
join规则
监视器规则
对于一个锁的解锁happens-before于后续对这个锁的加锁
volatile变量规则
对一个volatile域的写，happens-before于任意后续对这个volatile域的读
传递性规则
如果A happens-before B，切B happens-before C，那么A happens-before C
start()规则
如果线程A执行操作ThreadB.start()启动B线程，那么A线程的ThreadB.start()操作happens-before与线程B中的任意操作
join()规则
如果线程A执行操作ThreadB.join()并成功返回，那么线程B中的任意操作happens-before于线程A从ThreadB.join()操作成功返回
5.原子类Atomic-无锁工具的典范
原子性问题的解决方案
synchronized,Lock
JUC包下的Atomic类
实例：
atomicInteger.incrementAndGet();
public class AtomicTest {
//public static int i = 0;
public static AtomicInteger atomicInteger = new AtomicInteger(0);
public static void inc() throws InterruptedException {
Thread.sleep(1);
atomicInteger.incrementAndGet();
//i++;
}
public static void main(String[] args) throws InterruptedException {
for (int i1 = 0; i1 < 1000; i1++) {
new Thread(()->{
try {
AtomicTest.inc();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
//休眠4秒的原因为了让子线程执行完
Thread.sleep(4000);
//System.out.println(i);
System.out.println(atomicInteger);
}
}
运行结果如下：
不管执行多少次，结果都不改变
Atomic实现原理
Unsafe
CAS
查看如上代码执行源码分析：
atomicInteger.incrementAndGet();
unsafe.getAndAddInt
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
其中的valueOffset值初始化和赋值代码
private static final long valueOffset;
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
valueoffset就是从内存中获取value的值偏移量查看unsafe,getAndAddInt方法
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));//cas 类似乐观锁
return var5;
}
ThreadLocal的使用和原理
实例：
public class ThreadLocalDemo {
public static int num = 0;
public static void main(String[] args) {
Thread[] threads = new Thread[5];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
num+=5;
System.out.println(Thread.currentThread() + "->" + num);
},"Thread-" + i);
}
for (Thread thread : threads) {
thread.start();
}
}
}
运行结果如下：
可以发现执行结果错误
如果想要每个线程获取到的num的值不做变化需要如何修改
local.get();
public class ThreadLocalDemo {
public static int num = 0;
public static final ThreadLocal<Integer> local = new ThreadLocal<Integer>(){
@Override
protected Integer initialValue() {
return 0;
}
};
public static void main(String[] args) {
Thread[] threads = new Thread[5];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
int num = local.get();
num+=5;
local.set(num);
System.out.println(Thread.currentThread() + "->" + num);
},"Thread-" + i);
}
for (Thread thread : threads) {
thread.start();
}
}
}
运行结果如下：
local.get();源码分析
内的值
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();//获取线程内的值
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
ThreadLocal.ThreadLocalMap threadLocals = null;//每个线程私有的threadLocals
//初始化的时候执行
private T setInitialValue() {
T value = initialValue();//初始化值，返回null
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value); //初始化的时候执行
return value;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
核心方法：
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];//创建大小为16的entry
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//根绝local计算hash值
table[i] = new Entry(firstKey, firstValue);//给entry赋值，firstValue为0
size = 1;
setThreshold(INITIAL_CAPACITY);
}
local.set()方法源码分析：
//已经有值，执行该操作
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);//已经有值，执行该操作
else
createMap(t, value);//初始化
}
//扩容机制
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);//根据local计算hash值
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {//如果获取下一个
ThreadLocal<?> k = e.get();
if (k == key) { //如果修改的同一个local的值，直接覆盖
e.value = value;
return;
}
if (k == null) { //如果为空，因为local是弱引用类型，当对象被回收时候，需要修改值得引用
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)//扩容机制
rehash();
}
分析如下：
3968
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
