并发编程入门
前言
多线程是为了提升程序的运行速度。但是,当多线程访问同一个资源的时候,会产生线程安全的问题。
一、JMM
我们先来看下代码
public class TestThreadSafe {
boolean flag = true;
public static void main(String[] args) throws InterruptedException {
TestThreadSafe t = new TestThreadSafe();
new Thread(t::test).start();
TimeUnit.SECONDS.sleep(1);
t.flag = false;
}
void test(){
System.out.println("start");
while (flag){
}
System.out.println("end");
}
}
大家觉得这段代码有没有问题?本地运行可以发现,程序永远也终止不了。这就不得不提JMM(Java内存模型),如下图:
flag 是存在主内存当中的,如果线程要用到flag这个变量,必须从主内存中copy到自己的本地内存,这样可以提高程序的运行效率。这时候,虽然线程B对flag进行了修改,也写回到了主内存,但是线程A并不知道,它拿到的依然是本地内存中的flag。
二、并发三大特性
2.1. 可见性
为了解决上述代码中的问题,我们只需要稍微修改以下代码就可以:
volatile boolean flag = true;
volatile底层通过缓存一致性协议,将线程A的本地内存中的flag标记为无效,如果需要访问flag必须重新从主内存中读取,这就是所谓的线程可见性,在汇编层面的体现上就是 lock指令。
2.2. 原子性
请观看如下代码:
public class TestThreadSafe {
volatile int num = 0;
public static void main(String[] args) throws InterruptedException {
TestThreadSafe t = new TestThreadSafe();
for (int i = 0; i < 100; i++){
new Thread(t::test).start();
}
TimeUnit.SECONDS.sleep(2);
System.out.println(t.num);
}
void test(){
num++;
}
}
大家觉得num的值一定是100吗?答案是否定的。为什么加了volatile会不行呢?通过javap反编译我们可以发现:
num++操作是由三个指令组成,volatile只能保证可见性,无法保证原子性(即一组操作不能被打断),我们可以通过加锁解决
public class TestThreadSafe {
int num = 0;
public static void main(String[] args) throws InterruptedException {
TestThreadSafe t = new TestThreadSafe();
for (int i = 0; i < 100; i++){
new Thread(()->{
synchronized (t){
t.test();
}
}).start();
}
TimeUnit.SECONDS.sleep(2);
System.out.println(t.num);
}
void test(){
num++;
}
}
我们通过反编译可以观察到jvm层面的实现。
2.3. 指令重排序
我们都知道在单例模式中,有一种双重检查锁的创建方式,代码如下:
public class TestThreadSafe {
private static TestThreadSafe instance;
private TestThreadSafe() {
}
public static TestThreadSafe getInstance() {
if (instance == null) {
synchronized (TestThreadSafe.class) {
if (instance == null) {
instance = new TestThreadSafe();
}
}
}
return instance;
}
}
要知道其中的问题,我们首先得知道,创建对象一共分为三个步骤:
1:在内存中开辟一块空间
2:赋值
3:返回地址
那么在jvm执行过程中,它会发现第2步和第3步满足happens-before原则(即指令之间互不相关),那么很有可能是先返回地址再对内存空间进行赋值。如果出现这种情况,其他线程拿到的对象虽然不为空,但是里面根本就没有属性值,所以其他线程在操作的时候就会有问题。为了避免这种情况,需要将单例对象用volatile进行修饰。
volatile保证指令不可重排序的原理是通过内存屏障去解决。
三、synchronized的深入理解
3.1. 锁原理、锁升级
我们都知道,synchronized锁的是对象,那么对象到底在内存中是什么样的布局呢?我们可以通过以下方法直观看到:
<dependency>
<groupId>org.openjdk.jol</groupId>
<artifactId>jol-core</artifactId>
<version>0.9</version>
</dependency>
我们可以看到,对象由对象头和数据两个部分组成。对象头包含 markworld和classpoint组成。
通过这张图我们可以得出结论,刚创建的对象是一个无锁的状态或者说匿名偏向锁的状态。
当我们对对象进行synchronized的时候,可以发现:
这个时候,锁升级为了轻量级锁
我们再次对代代码进行修改:
可以发现锁已经升级为重量级的锁,即当一个线程通过cas自旋一定次数仍然无法获得锁,就会进行阻塞并升级锁。
3.2. 锁膨胀、锁消除
锁膨胀:在一个循环中,如果多次持有锁和释放锁,jvm可能会将synchronized优化到循环外部。
锁消除:在执行synchronized代码块时,如果发现没有共享数据的操作,jvm会自动把synchronized去掉。