java并发之并发关键字

并发关键字

关键字一：volatile

可以这样说，volatile 关键字是 Java 虚拟机提供的轻量级的同步机制。

功能

volatile 有 2 个主要功能：

可见性。一个线程对共享变量的修改，其他线程能够立即得知这个修改。普通变量不能做到这一点，普通变量的值在线程间传递需要通过主内存来完成。
禁止指令重排序。

底层原理

加入 volatile 关键字时，会多出 lock 前缀指令，该 lock 前缀指令相当于内存屏障，内存屏障会提供 3 个功能：

在执行到内存屏障这句指令时，在其前面的操作都已完成了
强制将 处理器行的数据缓存写回内存
一个处理器的缓存回写到内存会导致其他工作内存中的缓存失效

应用场景

状态标记

volatile + boolean

DCL 单例模式（Double Check Lock，双重校验锁）

public class Singleton {

    private volatile static Singleton singleton=null;

    private Singleton(){}

    public static Singleton getSingleton(){
        if(singleton==null){
            synchronized (Singleton.class){
                if(singleton==null){
                    singleton=new Singleton();
                }
            }
        }
        return singleton;
    }
}

关键字二：synchronized

线程安全问题:

存在共享数据（临界资源）
存在多条线程共同操作这些共享数据

解决：同步机制。

同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再对共享数据进行操作。

同步的前提：

多个线程
多个线程使用的是同一个锁对象

同步的弊端：

当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

功能

使用 synchroinzed 进行同步，可以保证原子性（保证每个时刻只有一个线程执行同步代码）和可见性（对一个变量执行 unlock 操作之前，必须把变量值同步回主内存）。

使用

synchronized 修饰的对象有几种：

修饰一个类。

作用范围是 synchronized 后面括号括起来的部分

作用对象是这个类的所有对象

class ClassName {
   public void method() {
      synchronized(ClassName.class) {
         // todo
      }
   }
}

修饰一个方法：被修饰的方法称为同步方法。

作用范围是整个方法

作用对象是调用这个方法的对象
```
public synchronized void method(){
   // todo
}
```
修饰一个静态的方法。

作用的范围是整个方法

作用对象是这个类的所有对象
```
public synchronized static void method() {
   // todo
}
```
修饰一个代码块：被修饰的代码块称为同步语句块

作用范围是大括号 {} 括起来的代码块

作用对象是调用这个代码块的对象

注意：如果锁的是类对象的话，尽管new多个实例对象，但他们仍然是属于同一个类依然会被锁住，即线程之间保证同步关系。

原理

public class SynchronizedDemo {
    public static void main(String[] args) {
        synchronized (SynchronizedDemo.class) { //锁住类对象
        }
        method();
    }

    private synchronized static void method() { //锁住类对象
    }
}

任意一个对象都拥有自己的 Monitor，当这个对象由同步块或者同步方法调用时，执行方法的线程必须先获取该对象的 Monitor 才能进入同步块和同步方法，如果没有获取到 Monitor 的线程将会被阻塞在同步块和同步方法的入口处，进入到 BLOCKED 状态。

synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令。

monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。

使用 synchronized 进行同步，其关键就是必须要对对象的 Monitor 进行获取，当线程获取 Monitor 后才能继续往下执行，否则就只能等待。而这个获取的过程是互斥的，即同一时刻只有一个线程能够获取到 Monitor。

上面的 SynchronizedDemo 中在执行完同步代码块之后紧接着再会去执行一个静态同步方法，而这个方法锁的对象依然就这个类对象，那么这个正在执行的线程还需要获取该锁吗？

答案是不必的，从上图中就可以看出来，执行静态同步方法的时候就只有一条 monitorexit 指令，并没有monitorenter 获取锁的指令。这就是锁的重入性，即在同一线程中，线程不需要再次获取同一把锁。 synchronized 先天具有重入性。每个对象拥有一个计数器，当线程获取该对象锁后，计数器就会 +1，释放锁后就会将计数器 -1。

synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的是 ACC_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

锁优化策略

JDK 1.6 之后对 synchronized 进行优化。

锁的 4 种状态：无锁、偏向锁、轻量级锁、重量级锁。

1. 自旋锁

在很多应用上，共享数据的锁定状态只会持续很短一段时间。自旋锁的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。

自旋锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。

在 JDK 1.6 中引入了自适应的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。

2. 锁消除

锁消除是指对于被检测出不可能存在竞争的共享数据的锁进行消除。

锁消除主要是通过逃逸分析来支持，如果堆上的共享数据不可能逃逸出去被其它线程访问到，那么就可以把它们当成私有数据对待，也就可以将它们的锁进行消除。

对于一些看起来没有加锁的代码，其实隐式的加了很多锁。例如下面的字符串拼接代码就隐式加了锁：

public static String concatString(String s1, String s2, String s3) {
    return s1 + s2 + s3;
}Copy to clipboardErrorCopied

String 是一个不可变的类，编译器会对 String 的拼接自动优化。在 JDK 1.5 之前，会转化为 StringBuffer 对象的连续 append() 操作：

public static String concatString(String s1, String s2, String s3) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    sb.append(s3);
    return sb.toString();
}Copy to clipboardErrorCopied

每个 append() 方法中都有一个同步块。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在concatString() 方法内部。也就是说，sb 的所有引用永远不会逃逸到 concatString() 方法之外，其他线程无法访问到它，因此可以进行消除。

3. 锁粗化

如果一系列的连续操作都对同一个对象反复加锁和解锁，频繁的加锁操作就会导致性能损耗。

上一节的示例代码中连续的 append() 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁的范围扩展（粗化）到整个操作序列的外部。对于上一节的示例代码就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，这样只需要加锁一次就可以了。