1.synchronized

1.1.synchronized 的作用?

在 Java 中，synchronized 关键字是用来控制线程同步的，就是在多线程的环境下，控制 synchronized 代码段不被多个线程同时执行。synchronized 可以修饰类、方法、变量。
另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁(monitor)是依赖于底层的操作系统的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的 synchronized 效率低的原因。庆幸的是在 Java 6 之后 Java 官方对 从 JVM 层面对synchronized 较大优化，所以现在的 synchronized 锁效率也优化得很不错了。JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。

1.2.说说自己是怎么使用 synchronized 关键字，在项目中用到了吗

synchronized关键字最主要的三种使用方式:

  • 1.修饰实例方法: 作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁
  • 2.修饰静态方法: 也就是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员( static 表明这是该类的一个静态资源，不管new了多少个对象，只有一份)。所以如果一个线程A调用一个实例对象的非静态 synchronized 方法，而线程B需要调用这个实例对象所属类的静态 synchronized 方 法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁。
  • 3.修饰代码块: 指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

总结: synchronized 关键字加到 static 静态方法和 synchronized(class)代码块上都是是给 Class 类上锁。synchronized 关键字加到实例方法上是给对象实例上锁。尽量不要使用 synchronized(String a) 因为JVM中，字符串常量池具有缓存功能!
双重校验锁实现对象单例(线程安全)

  1. public class Singleton{
  2.     // volatile 可以禁止 JVM 的指令重排
  3.     private volatile static Singleton uniqueInstance;
  5.     private Singleton(){
  6.     }
  7.     public static Singleton getUniqueInstance(){
  8.         // 首先判断对象是否实例化过，如果没有实例化过，才进去下一步
  9.         if(uniqueInstance == null){ 
  10.             // 类对象加锁
  11.             synchronized(Singleton.class){
  12.                 if(uniqueInstance == null){
  13.                     uniqueInstance = new Singleton();
  14.                 }
  15.             }
  16.         }
  17.         return uniqueInstance;
  18.     }
  19. }

需要注意 uniqueInstance 采用 volatile 关键字修饰也是很有必要。uniqueInstance = new Singleton(); 这段代码其实是分为三步执行:

  1. 为 uniqueInstance 分配内存空间
  2. 初始化 uniqueInstance
  3. 将 uniqueInstance 指向分配的内存地址

但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

1.3.说一下 synchronized 底层实现原理?

synchronized是Java中的一个关键字，在使用的过程中并没有看到显示的加锁和解锁过程。因此有必要通过javap命令，查看相应的字节码文件。synchronized 同步语句块的情况

  1. public class SynchronizedDemo{
  2.     public void method(){
  3.         synchronized(this){ 
  4.             System.out.println("synchronized代码块");
  5.         }
  6.     }
  7. }

通过JDK 反汇编指令

  1. javap -c -v SynchronizedDemo

image.png
可以看出在执行同步代码块之前之后都有一个monitor字样，其中前面的是monitorenter，后面的是离开monitorexit，不难想象一个线程也执行同步代码块，首先要获取锁，而获取锁的过程就是monitorenter ，在执行完代码块之后，要释放锁，释放锁就是执行monitorexit指令。
为什么会有两个monitorexit呢?
这个主要是防止在同步代码块中线程因异常退出，而锁没有得到释放，这必然会造成死锁(等待的线程永远获取不到锁)。因此最后一个monitorexit是保证在异常情况下，锁也可以得到释放，避免死锁。 仅有ACC_SYNCHRONIZED这么一个标志，该标记表明线程进入该方法时，需要 monitorenter，退出该方法时需要monitorexit。

1.4.synchronized可重入的原理

重入锁是指一个线程获取到该锁之后，该线程可以继续获得该锁。底层原理维护一个计数器，当线程获取该锁时，计数器加一，再次获得该锁时继续加一，释放锁时，计数器减一，当计数器值为0时，表明该锁未被任何线程所持有，其它线程可以竞争获取锁。

1.5.什么是自旋

很多synchronized 里面的代码只是一些很简单的代码，执行时间非常快，此时等待的线程都加锁可能是一种不太值得的操作，因为线程阻塞涉及到用户态和内核态切换的问题。既然 synchronized 里面的代码执行得非常快，不妨让等待锁的线程不要被阻塞，而是在 synchronized 的边界做自循环，这就是自旋。如果做了多次循环发现还没有获得锁，再阻塞，这样可能是一种更好的策略。

1.6.多线程中 synchronized 锁升级的原理是什么?

synchronized 锁升级原理:在锁对象的对象头里面有一个 threadid 字段，在第 一次访问的时候 threadid 为空，jvm 让其持有偏向锁，并将 threadid 设置为其 线程 id，再次进入的时候会先判断 threadid 是否与其线程 id 一致，如果一致则 可以直接使用此对象，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一 定次数来获取锁，执行一定次数之后，如果还没有正常获取到要使用的对象，此 时就会把锁从轻量级升级为重量级锁，此过程就构成了 synchronized 锁的升级。
锁的升级的目的:锁升级是为了减低了锁带来的性能消耗。在 Java 6 之后优化 synchronized 的实现方式，使用了偏向锁升级为轻量级锁再升级到重量级锁的方式，从而减低了锁带来的性能消耗。

1.7.线程 B 怎么知道线程 A 修改了变量

(1)volatile 修饰变量
(2)synchronized 修饰修改变量的方法
(3)wait/notify
(4)while 轮询

一种是线程 b 不断轮训共享变量，看一下是否变量有被修改，当然该变量要加上 volatile 关键字 当然还可以利用 wait(),notify()方法，即生产者、消费者模式，让生产者线程改变变量之后，主动通知、激活消费者线程，反之亦然

1.8.当一个线程进入一个对象的 synchronized 方法 A 之后，其它线程是否可进入此对象的 synchronized 方法 B?

不能。其它线程只能访问该对象的非同步方法，同步方法则不能进入。因为非静态方法上的 synchronized 修饰符要求执行方法时要获得对象的锁，如果已经进 入A 方法说明对象锁已经被取走，那么试图进入 B 方法的线程就只能在等锁池 (注意不是等待池哦)中等待对象的锁。

1.9.synchronized、volatile、CAS 比较

  • synchronized 是悲观锁，属于抢占式，会引起其他线程阻塞。
  • volatile 提供多线程共享变量可见性和禁止指令重排序优化。

  • CAS 是基于冲突检测的乐观锁(非阻塞)

    1.10.synchronized 和 Lock 有什么区别?

  • 首先synchronized是Java内置关键字，在JVM层面，Lock是个Java类;

  • synchronized 可以给类、方法、代码块加锁;而 lock 只能给代码块加锁。
  • synchronized 不需要手动获取锁和释放锁，使用简单，发生异常会自动释放锁，不会造成死锁;而 lock 需要自己加锁和释放锁，如果使用不当没有 unLock()去释放锁就会造成死锁。
  • 通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

    1.11.synchronized 和 ReentrantLock 区别是什么?

    synchronized 是和 if、else、for、while 一样的关键字，ReentrantLock 是类，这是二者的本质区别。既然 ReentrantLock 是类，那么它就提供了比 synchronized 更多更灵活的特性，可以被继承、可以有方法、可以有各种各样的类变量
    synchronized 早期的实现比较低效，对比 ReentrantLock，大多数场景性能都相差较大，但是在 Java 6 中对 synchronized 进行了非常多的改进。
    相同点:

    两者都是可重入锁。“可重入锁”概念是:自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。 同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时 才能释放锁。

主要区别如下:

  • ReentrantLock 使用起来比较灵活，但是必须有释放锁的配合动作;
  • ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁;
  • ReentrantLock 只适用于代码块锁，而 synchronized 可以修饰类、方法、变量等。

二者的锁机制其实也是不一样的。ReentrantLock 底层调用的是 Unsafe 的park 方法加锁，synchronized 操作的应该是对象头中 mark word
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础:

  • 普通同步方法，锁是当前实例对象 静态同步方法，锁是当前类的class对象
  • 静态同步方法，锁是当前类的class对象

  • 同步方法块，锁是括号里面的对象

    2.volatile

    2.1.volatile 关键字的作用

    对于可见性，Java 提供了 volatile 关键字来保证可见性和禁止指令重排。 volatile 提供 happens-before 的保证，确保一个线程的修改能对其他线程是可见的。当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。 从实践角度而言，volatile 的一个重要作用就是和 CAS 结合，保证了原子性，详细的可以参见 java.util.concurrent.atomic 包下的类，比如 AtomicInteger。 volatile 常用于多线程环境下的单次操作(单次读或者单次写)。

    2.2.Java 中能创建 volatile 数组吗?

    能，Java 中可以创建 volatile 类型数组，不过只是一个指向数组的引用，而不是整个数组。意思是，如果改变引用指向的数组，将会受到 volatile 的保护，但是如果多个线程同时改变数组的元素，volatile 标示符就不能起到之前的保护作用了。

    2.3.volatile 变量和 atomic 变量有什么不同?

    volatile 变量可以确保先行关系，即写操作会发生在后续的读操作之前, 但它并不能保证原子性。例如用 volatile 修饰 count 变量，那么 count++ 操作就不是原子性的。
    而 AtomicInteger 类提供的 atomic 方法可以让这种操作具有原子性如 getAndIncrement()方法会原子性的进行增量操作把当前值加一，其它数据类型和引用变量也可以进行相似操作。

    2.4.volatile 能使得一个非原子操作变成原子操作吗?

    关键字volatile的主要作用是使变量在多个线程间可见，但无法保证原子性，对于多个线程访问同一个实例变量需要加锁进行同步。 虽然volatile只能保证可见性不能保证原子性，但用volatile修饰long和double可以保证其操作原子性。
    所以从Oracle Java Spec里面可以看到:

  • 对于64位的long和double，如果没有被volatile修饰，那么对其操作可以不是原子的。在操作的时候，可以分成两步，每次对32位操作。

  • 如果使用volatile修饰long和double，那么其读写都是原子操作
  • 对于64位的引用地址的读写，都是原子操作
  • 在实现JVM时，可以自由选择是否把读写long和double作为原子操作
  • 推荐JVM实现为原子操作

    3.synchronized 和 volatile 的区别是什么?

    synchronized 表示只有一个线程可以获取作用对象的锁，执行代码，阻塞其他线程。volatile 表示变量在CPU的寄存器中是不确定的，必须从主存中读取。保证多线程环境下变量的可见性;禁止指令重排序。

区别

  • volatile 是变量修饰符;synchronized可以修饰类、方法、变量。 volatile 仅能实现变量的修改可见性，不能保证原子性;而synchronized 则可以保证变量的修改可见性和原子性。
  • volatile 不会造成线程的阻塞;synchronized 可能会造成线程的阻塞。
  • volatile标记的变量不会被编译器优化;synchronized标记的变量可以被编译器优化。

  • volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在 JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而 引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升， 实际开发中使用 synchronized 关键字的场景还是更多一些。

    4.final

    4.1.什么是不可变对象，它对写并发应用有什么帮助?

    不可变对象(Immutable Objects)即对象一旦被创建它的状态(对象的数据，也即对象属性值)就不能改变，反之即为可变对象(Mutable Objects)。 不可变对象的类即为不可变类(Immutable Class)。Java 平台类库中包含许多不可变类，如 String、基本类型的包装类、BigInteger 和 BigDecimal 等。
    只有满足如下状态，一个对象才是不可变的:

  • 它的状态不能在创建后再被修改;

  • 所有域都是 final 类型;并且，它被正确创建(创建期间没有发生 this 引用的逸出)。

不可变对象保证了对象的内存可见性，对不可变对象的读取不需要进行额外的同步手段，提升了代码执行效率。