有关并发编程技术基础知识

有关并发编程的基础知识

实现多线程的三种方式

（1）继承Thread类

（2）实现Runnable接口

（3）使用ExecutorService、Callable、Future实现有返回结果的多线程

Thread和Runable的区别和联系

Thread类实现了Runable接口，都需要重写run()方法。

实现Runnable的类更具有健壮性，避免了单继承的局限。Runnable更容易实现资源共享，能多个线程同时处理一个资源。

synchronized关键字

修饰的对象：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，作用的对象是调用这个代码块的对象；

2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

3. 修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

4. 修饰一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

Synchronized的作用主要有三个

确保线程互斥的访问同步代码，保证共享变量的可见性，顺序性。

Synchronized实现原理

Synchronized关键字可以修饰代码块，也可以修饰一个方法：

①修饰代码块的话底层使用两个指令标识实现的，进入代码块的时候用monitorenter指令获取对象的对象头里的monitor，出对象用monitorexit来释放。

monitorenter ：

每个对象的对象头里有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：

1.如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。

2.如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.

3.如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。

monitorexit：

执行monitorexit的线程必须是objectref所对应的monitor的所有者。

指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。 

其实wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

②修饰方法的话，用一个acc_synchronized标识来标识当前方法是否正在使用。

Synchronized锁的优化

JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。

锁主要存在四中状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

①偏向锁

引入偏向锁的目的是为了没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。但是与轻量锁不同是：轻量级锁在无竞争的情况下使用 CAS 操作去代替使用互斥量，而偏向锁在无竞争的情况下会把整个同步都消除掉。

② 轻量级锁

倘若偏向锁失败，虚拟机并不会立即升级为重量级锁，它还会尝试使用一种称为轻量级锁的优化手段(1.6之后加入的)。轻量级锁不是为了代替重量级锁，它的本意是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗，因为使用轻量级锁时，不需要申请互斥量。轻量级锁的加锁和解锁都用到了CAS操作（乐观锁）。

轻量级锁能够提升程序同步性能的依据是“对于绝大部分锁，在整个同步周期内都是不存在竞争的”，这是一个经验数据。如果没有竞争，轻量级锁使用 CAS 操作避免了使用互斥操作的开销。但如果存在锁竞争，除了互斥量开销外，还会额外发生CAS操作，因此在有锁竞争的情况下，轻量级锁比传统的重量级锁更慢！如果锁竞争激烈，那么轻量级将很快膨胀为重量级锁！

③ 自旋锁和自适应自旋

轻量级锁失败后，虚拟机为了避免线程在操作系统层面直接挂起，还会进行一项称为自旋锁的优化手段。

互斥同步对性能最大的影响就是阻塞的实现，因为挂起线程/恢复线程的操作都需要转入内核态中完成（用户态转换到内核态会耗费时间）。

一般线程持有锁的时间都不是太长，所以仅仅为了这一点时间去挂起线程/恢复线程是得不偿失的。所以，虚拟机的开发团队就这样去考虑：“我们能不能让后面来的请求获取锁的线程等待一会而不被挂起呢？看看持有锁的线程是否很快就会释放锁”。为了让一个线程等待，我们只需要让线程执行一个忙循环（自旋），这项技术就叫做自旋。

如果自旋超过了限定次数任然没有获得锁，就应该挂起线程。自旋次数的默认值是10次，用户可以自定义修改。

另外,在 JDK1.6 中引入了自适应的自旋锁。自适应的自旋锁带来的改进就是：自旋的时间不在固定了，而是和前一次同一个锁上的自旋时间以及锁的拥有者的状态来决定，虚拟机变得越来越“聪明”了。

④ 锁消除

锁消除理解起来很简单，它指的就是虚拟机即使编译器在运行时，如果检测到那些共享数据不可能存在竞争，那么就执行锁消除。锁消除可以节省毫无意义的请求锁的时间。

⑤ 锁粗化

原则上，我们再编写代码的时候，总是推荐将同步快的作用范围限制得尽量小——只在共享数据的实际作用域才进行同步，这样是为了使得需要同步的操作数量尽可能变小，如果存在锁竞争，那等待线程也能尽快拿到锁。

大部分情况下，上面的原则都是没有问题的，但是如果一系列的连续操作都对同一个对象反复加锁和解锁，那么会带来很多不必要的性能消耗。

Lock类型的锁

Lock锁与Synchronized锁不同，Synchronized锁是基于JVM实现的，Lock锁是JDK层面的锁。

Lock锁的底层用的是AQS实现的，AQS也就是abstractQueueSynchronized，AQS的核心思想就是如果请求的资源是空闲的，就可以直接把当前请求的线程设置为有效的工作线程。如果请求资源在被使用，就把这个请求线程加入AQS的clh队列里。AQS判断一个资源是否被正在使用，用的是一个int类型的变量，0表示未使用，1表示在被使用，大于1表示重入次数。AQS提供了模板方法，继承了lock类的锁可以用他的内部类继承AQS，重写AQS的tryAcquire tryRelease等方法，lock的派生类都是利用这个内部类来具体实现独占锁共享锁，公平锁非公平锁。比如独占锁reentrantlock，倒计时器countdownlatch，cyclicbarrir。

Lock锁是乐观锁，主要基于volatile和CAS锁实现。

线程的状态

线程的阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。

线程什么时候会进入阻塞状态？

（1）等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放线程持有的锁)

（2）同步阻塞：运行的线程在获取共享资源的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中（挂起）。

（3）其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。

sleep()与wait()的区别？

Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。但是sleep是不释放锁的。

ConcurrentLinkedQueue和LinkedBlockingQueue的区别

阻塞队列与非阻塞队列，一般来说，生产者消费者用到的是阻塞队列。

在之前的博客中，我对阻塞与非阻塞的概念做了描述，这里可以很清楚的明白，阻塞队列是在没有资源的情况下，会挂起线程。非阻塞会使用CAS锁去不断尝试资源，线程不会挂起。

volatile关键字

volatile的作用是用来保证可见性以及顺序性：

可见性就是当多个线程并发访问共享变量时，一个线程对共享变量的修改，其它线程能够立即看到。

顺序性指程序执行的顺序按照代码的先后顺序执行（因为虚拟机会对代码的执行做优化操作，会导致顺序与代码不一致）

volatile的实现原理：

volatile加入之后，会在底层的汇编命令前加上一个lock前缀指令，相当于一个内存屏障。

这个内存屏障的作用是确保后面的运行指令不会调到lock指令前面，前面的也不会调到后面，保证了顺序性。

同时会强制对寄存器缓存的修改操作立即写入主存当中，保证了可见性。

保证线程安全

什么是线程安全？

多线程访问同一段代码或同一个资源不会产生不一致的结果。

如何保证线程安全？

threadLocal，synchronized，volatile，lock锁

线程的退出方式

安全退出，等线程执行完成后，正常退出；

使用 interrupt() 方法中断线程；

使用 stop 方法强行终止线程（不安全）

守护线程

守护线程对其他的对象或线程提供服务，在没用线程可以服务时自动离开（JVM垃圾回收机制）