多线程(安全同步线程池)

线程安全问题

多线程给我们的程序带来了很大性能上的提升，但是也可能引发线程安全问题
线程安全问题指的是当多个线程同时操作同一个共享资源的时候，可能会出现的操作结果不符预期问题

取钱的线程安全问题

线程安全问题出现的原因？
- 存在多线程并发
- 同时访问共享资源
- 存在修改共享资源
线程安全问题发生的原因是什么？
- 多个线程同时访问同一个共享资源且存在修改该资源。

线程同步方案

认识线程同步

思想

线程同步就是让多个线程实现先后依次访问共享资源，这样就解决了安全问题，它最常见的方案就是加锁
**加锁：**每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来。

同步代码块(方式一)

作用: 把访问共享资源的核心代码给上锁，以此保证线程安全。

synchronized(同步锁) { 访问共享资源的核心代码 }

同步锁的注意事项

对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug
对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码（类名.class）对象作为锁对象

同步方法(方式二)

Lock锁(方式三)

Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。

Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象。

构造器	说明
public ReentrantLock()	获得Lock锁的实现类对象

方法

方法名称	说明
void lock()	获得锁
void unlock()	释放锁

总结(三种方式对比)

	同步代码块	同步方法	lock
语法	synchronized (this){ }	synchronized 方法(){ }	lock.lock(); lock.unlock();
加锁方式	自动加锁、释放锁	自动加锁、释放锁	手动加锁、释放锁
锁粒度	代码行	方法	代码行

线程池(重点)

认识线程池

当前创建线程的问题

用户每发起一个请求，后台就需要创建一个新线程来处理，任务处理完毕之后，线程就会被销毁
下次新任务来了肯定又要创建新线程处理的，用完又要被销毁
而创建和销毁线程的开销是很大的，当请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能

什么是线程池？

线程池就是一个可以复用线程的技术
它就像一个大的池子一样，里面可以放置一些线程，当需要的时候，就从里面取出来用，用完了就还回去
如此一来，就不必频繁的创建和销毁线程了，大大的提高了线程的利用率，提供系统的性能

不使用线程池的问题

如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

工作原理

线程池的执行流程

判断核心线程数是否已满，如果没满，则创建一个新的核心线程来执行任务
如果核心线程满了，则判断工作队列是否已满，如果没满，则将任务存储在这个工作队列
如果工作队列满了，则判断最大线程数是否已满，如果没满，则创建临时线程执行任务
如果最大线程数已满，则执行拒绝策略

如何创建线程池

谁代表线程池

JDK 5.0起提供了代表线程池的接口：ExecutorService。

如何得到线程池对象?

使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象。

public ThreadPoolExecutor( int corePoolSize,
                          int maximumPoolSize, 
                          long keepAliveTime, 
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue, 
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) 

参数一：corePoolSize : 指定线程池的核心线程的数量     正式工: 3  (不能小于0)                   
参数二：maximumPoolSize：指定线程池的最大线程数量	最大员工数: 5	临时工: 2  (最大数量>=核心线程数量)
参数三：keepAliveTime ：指定临时线程的存活时间	(不能小于0) 	
参数四：unit：指定临时线程存活的时间单位(秒、分、时、天）	临时工空闲多久被开除   (时间单位)
参数五：workQueue：指定线程池的任务队列		客人排队的地方		(null)
参数六：threadFactory：指定线程池的线程工厂	负责招聘员工的 	(null)
参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）	忙不过来怎么办    	(null)

线程池如何处理Runnable任务

使用ExecutorService的方法：
void execute(Runnable target)

线程池如何处理Callable任务，并得到任务执行完后返回的结果。

使用ExecutorService的方法：
Future submit(Callable command)

Executors工具类底层是基于什么方式实现的线程池对象？

线程池ExecutorService的实现类：ThreadPoolExecutor

Executors是否适合做大型互联网场景的线程池方案？

不合适。
建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规则，规避资源耗尽的风险。

任务缓冲队列

队列	详解
ArrayBlockingQueue	基于数组的有界缓存等待队列，可以指定缓存队列的大小
LinkedBlockingQueue	基于链表的无界阻塞队列，此时最大线程数无效

任务拒绝策略

策略	详解
ThreadPoolExecutor.AbortPolicy	丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy：	丢弃任务，但是不抛出异常这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用任务的run()方法从而绕过线程池直接执行

线程池处理Runnable任务

ExecutorService的常用方法

方法名称	说明
void execute(Runnable command)	执行 Runnable 任务
Future submit(Callable task)	执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果
void shutdown()	等全部任务执行完毕后，再关闭线程池！
List shutdownNow()	立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

线程池如何处理Runnable任务

使用ExecutorService的方法：void execute(Runnable target)

线程池处理Callable任务

ExecutorService的常用方法

方法名称	说明
void execute(Runnable command)	执行任务/命令，没有返回值，一般用来执行 Runnable 任务
Future submit(Callable task)	执行任务，返回未来任务对象获取线程结果，一般拿来执行 Callable 任务
void shutdown()	等任务执行完毕后关闭线程池
List shutdownNow()	立刻关闭，停止正在执行的任务，并返回队列中未执行的任务

线程池如何处理Callable任务，并得到任务执行完后返回的结果？

使用ExecutorService的方法：Future<T> submit(Callable<T> command)

Executors工具类实现线程池

Executors

**是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。 **

方法名称	说明
public static ExecutorService newFixedThreadPool(int nThreads)	创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
public static ExecutorService newSingleThreadExecutor()	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
public static ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。

注意：这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。

Executors使用可能存在的陷阱

大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

总结

Executors工具类底层是基于什么方式实现的线程池对象？
- 线程池ExecutorService的实现类：ThreadPoolExecutor
Executors是否适合做大型互联网场景的线程池方案？
- 不合适。
- 建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规则，规避资源耗尽的风险。

线程通信(了解)

**什么是线程通信? **

当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺。

线程通信的常见模型（生产者与消费者模型）

生产者线程负责生产数据
消费者线程负责消费生产者生产的数据。
注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，再通知生产者生产！

线程通信的三个常见方法

方法名称	说明
void wait()	当前线程等待，直到另一个线程调用notify() 或 notifyAll()唤醒自己
void notify()	唤醒正在等待对象监视器(锁对象)的单个线程
void notifyAll()	唤醒正在等待对象监视器(锁对象)的所有线程

注意
- 上述方法应该使用当前同步锁对象进行调用。

理论补充

进程与线程

进程：正在运行的程序（软件）就是一个独立的进程
线程：线程是属于进程的，一个进程中可以同时运行很多个线程
关系：进程=火车线程=车厢

并发与并行

并发的含义

进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，
CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发

并行的含义

在同一个时刻上，同时有多个线程在被CPU调度执行。

多线程到底是如何执行的?

并发与并行同时进行的

线程生命周期

也就是线程从生到死的过程中，经历的各种状态及状态转换，Java总共定义了6种状态

public class Thread{ ...  
    public enum State {
    NEW, 线程刚被创建，但是并未启动
	RUNNABLE, 线程已经调用了start()，等待CPU调度
	BLOCKED, 线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态
	WAITING, 一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
	TIMED_WAITING, 同waiting状态，有几个方法（sleep,wait）有超时参数，调用他们将进入Timed Waiting状态
	TERMINATED; 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡
	}
     ...
}

线程的6种状态互相转换

补充知识：定时器

补充知识：并发、并行

简单说说并发和并行的含义
- 并发：CPU分时轮询的执行线程。
- 并行：同一个时刻同时在执行。

线程的生命周期(背诵)

线程的6种状态总结

NEW(新建)	线程刚被创建，但是并未启动。
Runnable(可运行)	线程已经调用了start()等待CPU调度
Blocked(锁阻塞)	线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态；。
Waiting(无限等待)	一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。