线程专题——基本

基础问题
实现线程有哪些方式
产生线程安全问题的原因
线程安全问题的解决办法

实现线程有哪些方式
继承Thread类； thread001
实现Runnable接口；thread002
实现Callable接口；thread003 有返回值的线程
线程池（Spring提供的线程池：ThreadPoolTaskExecutor）

线程在生命周期内存在的状态
NEW，即新建状态，是线程被创建且为启动的状态。
RUNNABLE，即就绪状态，是调用start()之后运行之前的状态。
RUNNING，即运行状态，是run()正在执行时线程的状态。
BLOCKED，即阻塞状态。例：同步阻塞，锁被其他线程占用。
DEAD，即终止状态，是run()执行结束，或因异常退出后的状态，此状态不可逆转。

实现Runnable接口和实现Callable接口的区别
Callable有返回值，Runnable没有返回值；
Runnable没有容错机制，如果出现异常必须立即处理；Callable有容错机制出现异常之后可以向上抛出；
执行Callable方式，需要FutureTask实现类的支持，用于接收运算结果。

线程池的概念（理解）
线程池就是首先创建一些线程，它们的集合称为线程池。
使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，
执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

线程池的作用
利用线程池管理并复用线程、控制最大并发数等。
实现任务线程队列缓存策略和拒绝策略。
实现某些与时间相关的功能，如定时执行、周期执行等。定时器（就是一个注解）
隔离线程环境，在同一台服务器上，分别开启多个线程池。

JDK提供的四种常见的线程池（要求记住四种线程池的名称，理解详细说明）：
单线程线程池SingleThreadPool：有且仅有一个工作线程执行任务，所有任务按照指定顺序执行，即遵循队列的入队出队规则。
定长线程池FixedThreadPool：该线程池的最大线程数等于核心线程数，所以在默认情况下，该线程池的线程不会因为闲置状态超时而被销毁。

	如果当前线程数小于核心线程数，并且也有闲置线程的时候提交了任务，这时也不会去复用之前的闲置线程，会创建新的线程去执行任务。
	如果当前执行任务数大于了核心线程数，大于的部分就会进入队列等待。等着有闲置的线程来执行这个任务。
可缓存线程池CachedThreadPool：这种线程池内部没有核心线程，线程的数量是有没限制的。
	当线程池大小超过了处理任务所需的线程，那么就会回收部分空闲（一般是60秒无执行）的线程，当有任务来时，又智能的添加新线程来执行。
调度线程池ScheduledThreadPool：有延迟执行和周期执行任务功能的线程池。 定时器

Spring提供的线程池
ThreadPoolTaskExecutor。thread004
线程池的配置：
a.设置核心线程数；corePoolSize
b.最大线程数；maximumPoolSize
c.队列容量 workQueue
d.拒绝策略。handler ***** https://blog.csdn.net/u010002184/article/details/80847398
ThreadPoolExecutor.AbortPolicy（堕胎策略）:丢弃任务并抛出RejectedExecutionException异常。默认的拒绝策略是：AbortPolicy
ThreadPoolExecutor.DiscardPolicy（废弃策略）：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy（弃旧策略）：丢弃队列最前面的任务，执行后面的任务
ThreadPoolExecutor.CallerRunsPolicy（呼叫者运行策略）：由调用线程处理该任务

	e.线程创建工厂 threadFactory 
	f.线程被回收前的空闲时间 keepAliveTime 

应用：
	可以利用多线程/线程池实现异步功能。thread004

产生线程安全问题的原因
多个线程在操作共享的数据；操作共享数据的线程代码有多条。
简单的说，当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。thread006

Java中每个对象都有两个池：锁池（monitor）、等待池（waitset）。

锁池：假设线程A已经拥有了某个对象（不是类）的锁，而其他线程也想要调用这个对象的某个synchronized方法或者代码块。
由于这些线程在进入对象的synchronized方法或者代码块时，必须要先获得该对象的锁的拥有权，但是该对象的锁正在被线程A拥有，
所以这些线程就进入了该对象的锁池。

等待池：假设线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁
（原因是wait()必须出现在synchronized锁里面，自然执行wait()方法前就拥有了这个对象的锁，源代码翻译中提到wait()释放监视器所有权，即释放锁）
，同时线程A进入该对象的等待池中。
如果另一个线程调用了该相同对象的notifyAll()方法，那么处于该对象中的所有线程会进入该对象的锁池中，准备争夺锁的拥有权。
如果另一个线程调用了该相同对象的notify()方法，那么仅仅只有一个处于该对象的等待池中的线程（随机的某个）进入锁池，准备得到锁的拥有权。



简单理解：

如果线程调用了对象的wait()方法，那么线程就处于该对象的等待池中，等待池中的线程不会去争夺锁的拥有权。

当线程调用了该对象的notify()方法或者notifyAll()方法，被唤醒的线程进入锁池，准备争夺锁的拥有权。
假如某个线程没有争夺到锁，它仍旧停留在锁池中等待下一次的争夺，只有再次调用wait()方法才会进入等待池中。

wait()方法和sleep（）方法的区别：
sleep方法不会释放锁，但是wait方法会释放锁

线程安全问题的解决办法
同一时刻有且只有一个线程在操作共享数据，其它线程必须等到该线程处理完数据后再对共享数据进行操作。
synchronized同步方法或同步代码块；thread007
Lock锁；thread008
Redis分布式锁。thread009

关于Redis分布式锁的说明(下节课讲)
当多个进程不在同一个系统中，可以使用分布式锁控制多个进程对同一资源的访问。因为在分布式情况下（多JVM），线程A和线程B很可能不是在同一JVM中，这样线程锁就无法起到作用了，这时候就要用到分布式锁来解决。
为了确保分布式锁可用，我们至少要确保锁的实现同时满足以下四个条件：
互斥性。在任意时刻，只有一个客户端能持有锁。
防止死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
容错性。只要大部分的Redis节点正常运行，客户端就可以加锁和解锁。
加锁和解锁必须是同一个客户端。
网上部分工具类使用如下redis命令实现分布式锁：setnx(key, value)、expire(key, seconds)，但直接使用这些命令会存在死锁问题。

互斥锁的特性
互斥性：即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程的协调机制，这样在同一时间
只有一个线程对需要同步的代码块进行访问。 互斥性也称为操作的原子性。
可见性：必须确保在锁被释放之前，对共享变量所做的修改对于随后获得该锁的另一个线程是可见的，否则另一个
线程可能在本地缓存的某个副本上继续操作，从而引起不一致。

synchronized(){}扩展
锁的不是代码，锁的都是对象。
根据获取的锁的分类：获取对象锁和获取类锁。
获取对象锁的两种用法：
同步代码块，锁是小括号()中的实例对象。
同步非静态方法，锁是当前对象的实例对象。
获取类锁的两种用法
同步代码块，锁是小括号()中的类对象(Class对象)。
同步静态方法，锁是当前对象的类对象(Class对象)。
同一个类的不同对象的对象锁互不干扰。
同一个类的不同对象使用类锁将会是同步的。
类锁和对象锁互不干扰。

可重入性
某个线程试图获得一个已经由它自己持有的锁，那么这个请求就会成功(重复获取)，这就叫互斥锁的可重入性。
“重入”意味着获取锁的操作的粒度是“线程”，而不是调用，也就是说一个线程中可以针对同一个锁多次获取，而不需要阻塞等待。thread010

synchronized的四种状态
无锁 CAS
偏向锁
优点：没有额外的性能消耗，和执行非同步方法相比仅存在纳秒级的差距。
缺点：如果线程间存在锁竞争，会带来额外的锁撤销的消耗。
使用场景：只有一个线程访问同步块或者同步方法的场景。
核心思想：在锁对象的对象头中有一个ThreadId字段，当第一个线程访问锁时，如果该锁没有被其他线程访问过，即ThreadId字段为空，
那么JVM让其持有偏向锁，并将ThreadId字段的值设置为该线程的ID。
当下一次获取锁时，会判断当前线程的ID是否与锁对象的ThreadId一致。如果一致那么该线程不会再重复获取锁，从而提高了程序的运行效率。
轻量级锁
优点：竞争的线程不会阻塞，提高了响应速度。
缺点：若线程长时间抢不到锁，自旋会消耗CPU性能。
使用场景：线程交替执行同步块或者同步方法的场景。
重量级锁
优点：线程竞争不使用自旋，不会消耗CPU。
缺点：线程阻塞，响应时间缓慢，在多线程下，频繁的获取释放锁，会带来巨大的性能消耗。
使用场景：追求吞吐量，同步块或者同步方法执行时间较长的场景。

自旋锁
许多情况下，共享数据的锁定状态持续时间较短，切换线程不值得。
通过让线程执行忙循环等待锁的释放，不让出CPU。
缺点：若锁被其它线程长时间占用，会带来许多性能上的开销。

自适应自旋锁
自旋的次数不再固定。
由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。

ReentrantLock（再入锁）
位于java.util.concurrent.locks包。
能够实现比synchronized更细粒度的控制，如控制fairness（公平性）。
调用lock()后，必须调用unlock()释放锁。
性能未必比synchronized高，并且是可重入的。

ReentrantLock公平性的设置
ReentrantLock fairLock = new ReetrantLock(true);
参数为true时，倾向于将锁赋予等待时间最久的线程。
公平锁：获取锁的顺序按先后调用lock方法的顺序。
非公平锁：抢占的顺序不一定，synchronized是非公平锁。

ReentrantLock和synchronized的区别
ReentrantLock显示的获得、释放锁，synchronized隐式获得释放锁
ReentrantLock是API级别的，synchronized是JVM级别的
ReentrantLock可以实现公平锁
Lock是一个接口，而synchronized是Java中的关键字
synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；
Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁。

J.U.C包的分类 https://www.cnblogs.com/gxyandwmm/p/9398934.html
线程执行器Executor
锁locks
原子变量类atomic（采用的是乐观锁策略去原子更新数据，在java中则是使用CAS操作具体实现。）
并发工具类tools
并发集合collections

并发工具类
闭锁CountDownLatch
让主线程等待一组事件发生后继续执行，事件指的是CountDownLatch里的countDown()方法。
栅栏CyclicBarrier
阻塞当前线程，等待其它线程，且会阻塞自己当前线程，
所有线程必须同时到达栅栏位置后，才会继续执行；所有线程到达栅栏处，可以触发执行另外一个预先设置的线程。
信号量Semaphore
控制某个资源可被同时访问的线程个数。
交换器Exchanger
两个线程到达同步点后，相互交换数据。

CAS（Compare And Swap）
比较并交换。
CAS算法的实现过程：它包含3个参数CAS(V,E,N)。V表示要更新的变量(内存值)，E表示预期值(旧的)，N表示新值。
当且仅当V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程做了更新，则当前线程什么都不做。
最后，CAS返回当前V的真实值。(乐观锁的原理)
CAS会导致“ABA问题”。解决方案：使用AtomicStampedReference（原子标记参考）控制变量的版本来解决CAS的问题
version 1.0 2 version 2.0 3 version 3.0 2

	CAS算法实现一个重要前提需要取出内存中某时刻的数据，而在下时刻比较并替换，那么在这个时间差类会导致数据的变化。
	比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且two进行了一些操作变成了B，然后two又将V位置的数据变成A，
		这时候线程one进行CAS操作发现内存中仍然是A，然后one操作成功。尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的。

Amino框架
https://blog.csdn.net/tyfengyu/article/details/25200767

该组件将提供一套免锁的集合类（LockFreeVector、LockFreeList、LockFreeSet等）、树结构、图结构。因为这些数据结构采用免锁的运算法则来生成，所以，它们将拥有基本的免锁组件的特性，如可以避免不同类型的死锁，不同类型的线程初始化顺序等。?

Amino?还提供了一些非常有用的并行计算模式，包括?Master-Worker、Map-reduce、Divide?and?conquer,?Pipeline?等。?

Amino并没有加入到官方jdk中，因此需要自行下载、导入。
下载地址：http://sourceforge.net/projects/amino-cbbs/files/