多线程相关概念和线程池

多线程相关概念和线程池

1.前言

其实在平时的工作中用到多线程相关的问题时&＃xff0c;总是遇到一个就解决一个,从来没有在宏观上去看它们, 也就达不到所谓的"看山还是山&＃xff0c;看水还是水"。在系统的总结多线程之前&＃xff0c;先总结一些基本的概念

声明:部分观点仅由思考所得&＃xff0c;欢迎讨论和指正.

2.多线程

条件&＃xff1a;在一个进程下

2.1单cpu下的多线程称之为并发  

2.2多cpu下的多线程称之为并行

单cpu和多cpu的问题&＃xff0c;后面还会再讨论&＃xff0c;其实可以把多cpu看成单cpu来处理一些问题。

3.多线程的好处

3.1 以更简单的方式高效的使用系统资源(如cpu等)
因为一个程序运行的时候&＃xff0c;并不是一直使用cpu&＃xff0c;cpu的任务是处理和计算&＃xff0c;当有其他操作并不使用cpu的时候(比如说进行读取磁盘文件的时候)&＃xff0c;这时改变操作顺序&＃xff0c;可以减少cpu空闲的时间&＃xff1a;
A&＃xff1a; 一般情况下&＃xff0c;处理多个文件&＃xff1a;
5秒读取文件A
2秒处理文件A
5秒读取文件B
2秒处理文件B
---------------------
总共需要14秒
B&＃xff1a;采用更好的算法&＃xff0c;处理多个文件&＃xff1a;
5秒读取文件A
5秒读取文件B &＃43; 2秒处理文件A
2秒处理文件B
---------------------
总共需要12秒
分析&＃xff1a;在使cpu等资源的利用率高这个方面&＃xff0c;明显B方法更好&＃xff0c;但是这种算法或者说思想该如何实现呢&＃xff1f;
我们看到这种思想的本质是保持cpu等系统资源的繁忙。
实现&＃xff1a;那么我们可以采用单线程的方式&＃xff0c;只要设置好相关的文件状态即可&＃xff0c;达到B这种思想。但是在cpu的使用方面&＃xff0c;这种思想有了更好的实现方式&＃xff0c;那就是多线程&＃xff0c;多线程会抢夺cpu等资源&＃xff0c;完全符合了B这种"保持cpu等繁忙"的本质。所以说&＃xff0c;实现系统高效的是B这种算法&＃xff0c;而多线程让这种算法的代码实现变得简单。这才是多线程真正的好处之一

3.2 多线程的另一个好处是让大部分的用户感觉更快
这个都比较熟悉&＃xff0c;对于多个用户来说&＃xff0c;同一段时间内&＃xff0c;是完成一个用户的全部任务&＃xff0c;还是完成多个用户的一部分任务 对用户来说体验更好&＃xff1f; 当然是后者了。
 注意&＃xff1a;前面提到了单cpu和多cpu的问题&＃xff0c;个人以为完全可以把多cpu当作单cpu来看待&＃xff0c;多个cpu依然是一种资源&＃xff0c;而且每一个cpu都高效的话&＃xff0c;整个应用也会高效。 就像单兵&＃xff0c;提高个人技巧&＃xff0c;无疑在solo中更有优势&＃xff0c;如果是一个部队&＃xff0c;提高每个人的技巧&＃xff0c;整个部队也一定会更优秀。

4.多线程的代价

4.1 有形的代价

A:空间 每开辟一个线程&＃xff0c;就会占用一些内存空间
B:时间 每切换一次线程&＃xff0c;就会消耗部分时间

4.2 无形的代价

A:多线程实现了前面说到的B算法&＃xff0c;它能够保证cpu在一个时间点&＃xff0c;只有一个线程在访问&＃xff0c;但是对于其他的 资源&＃xff0c;比如说全局变量&＃xff0c;多个线程并不是按顺序访问的&＃xff0c;可能会同时访问&＃xff0c;所以要使用锁等办法&＃xff1b;在访问两个及以上的资源时&＃xff0c;也是不按顺序的&＃xff0c;所以会有死锁。也就是说&＃xff0c;多线程在cpu方面帮我们实现了算法B而在其他的资源方面&＃xff0c;需要我们自己实现算法B&＃xff0c;需要手动保证每个资源的访问顺序&＃xff0c;而锁&＃xff0c;同步&＃xff0c;信号量等都是为了实现自己的算法B而产生的一些技术&＃xff0c;也可以说是多线程在高效使用cpu时带来的一些副作用&＃xff1b;

B:学习成本和使用成本&＃xff1b;可能需要花很多时间去学习&＃xff0c;更有可能花更多的时间去使用和调试它

注意&＃xff1a;再深入思考一下&＃xff0c;似乎发现多线程的本质。由单到多&＃xff0c;带来的不就是顺序的问题么&＃xff0c;多线程帮我们保证了访问cpu的顺序&＃xff0c;那么访问其他资源的顺序怎么保证&＃xff0c;当然是自己来保证&＃xff1b; 所以&＃xff0c;"解决多线程相关的问题&＃xff0c;就是解决除cpu外的资源的使用顺序问题"。

5.多线程的创建方式和使用

5.1 创建方式

public static void main(String[] args) {/*Thread方式&＃xff1a;一种是继承Thread类&＃xff0c;一种是像下面这样使用匿名内部类*/Thread thread1 &＃61; new Thread(){&＃64;Overridepublic void run() {System.out.println("Multi.main(...).new Thread() {...}.run()");}};thread1.start();/*Runnable方式&＃xff1a;一种是实现一个接口Runnable&＃xff0c;一种是像下面这样使用匿名内部接口*/Runnable runnable &＃61; new Runnable() {public void run() {System.out.println("Multi.main(...).new Runnable() {...}.run()");}};Thread thread2 &＃61; new Thread(runnable);thread2.start();}/*main method*/

5.2 认识一下两个名词

A.竞态条件&＃xff1a;当两个线程竞争同一资源时&＃xff0c;如果对资源的访问顺序敏感&＃xff0c;就称存在竞态条件

B.临界区&＃xff1a;导致竞态条件发生的代码区称作临界区&＃xff1b;在临界区中使用适当的同步就可以避免竞态条件。

通过示例来看一下:

public class Counter {protected long count &＃61; 0;public void add(long value){this.count &＃61; this.count &＃43; value; }}

上面的add()方法就是临界区&＃xff0c;它会产生竞态条件&＃xff0c;当两个线程同时访问这个add方法就可能会导致count 的值不一致。

因为JVM的执行按照下面顺序&＃xff1a;

5.3 线程安全&＃xff0c;下面给出一个自己的定义&＃xff1a;
一段资源(代码)是线程安全的条件&＃xff1a;
A&＃xff1a;如果其中仅存在一类资源(代码)&＃xff0c;这类资源(代码)不被多个线程共同执行写操作。
B&＃xff1a;如果还存在指向资源(代码)的引用&＃xff0c;且它所指向的资源(代码)是线程安全的
上面两个结合就是线程安全的定义&＃xff0c;而且这个定义是递归的。

注意&＃xff1a;
1)条件A指明只有写操作才会引起线程不安全
2)上面的条件B是有必要的&＃xff0c;看下面的示例&＃xff1a;
两个线程都创建了各自的数据库连接&＃xff0c;每个连接自身是线程安全的&＃xff0c;但它们所连接到的同一个数据库也许不是线程安全的。
比如&＃xff0c;2个线程执行如下代码&＃xff1a;
检查记录X是否存在&＃xff0c;如果不存在&＃xff0c;插入X
如果两个线程同时执行&＃xff0c;而且碰巧检查的是同一个记录&＃xff0c;那么两个线程最终可能都插入了记录&＃xff1a;
线程1检查记录X是否存在。检查结果&＃xff1a;不存在
线程2检查记录X是否存在。检查结果&＃xff1a;不存在
线程1插入记录X
线程2插入记录X
同样的问题也会发生在文件或其他共享资源上。因此&＃xff0c;区分某个线程控制的对象是资源本身&＃xff0c;还是仅仅到某个资源的引用很重要。

6.线程池

6.1.线程池的概念

6.1.1 为什么要使用线程池(本质)
1)减少了每次都要创建线程的麻烦
2)线程池可以设置合理的线程数目&＃xff0c;手动创建线程不方便了解系统已经存在的线程数目。
6.1.2 为什么要使用队列
在使用线程池的时候&＃xff0c;可能会有请求无法及时处理&＃xff0c;这个时候就需要队列&＃xff0c;而且是阻塞队列。阻塞队列的特点是&＃xff0c;在队列中没有数据的情况下&＃xff0c;线程池中的所有线程都会被自动阻塞&＃xff0c;直到有数据放入队列&＃xff1b;在队列中填满数据的情况下&＃xff0c;队列中的所有请求都会被自动阻塞&＃xff0c;直到队列中有空的位置&＃xff0c;线程被自动唤醒。 

6.2 线程池相关的类

Java里面线程池的顶级接口是Executor&＃xff0c;但是严格意义上讲Executor并不是一个线程池&＃xff0c; 而只是一个执行线程的工具。真正的线程池接口是ExecutorService

6.3 如何使用线程池

6.3.1 先看一下ThreadPoolExecutor的构造函数

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
corePoolSize - 池中所保存的线程数&＃xff0c;包括空闲线程。
maximumPoolSize-池中允许的最大线程数。
keepAliveTime - 当线程数大于核心时&＃xff0c;此为终止前多余的空闲线程等待新任务的最长时间。
unit - keepAliveTime 参数的时间单位。
workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute方法提交的 Runnable任务。
threadFactory - 执行程序创建新线程时使用的工厂。
handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。
ThreadPoolExecutor是Executors类的底层实现。corePoolSize - 池中所保存的线程数&＃xff0c;包括空闲线程。
maximumPoolSize-池中允许的最大线程数。
keepAliveTime - 当线程数大于核心时&＃xff0c;此为终止前多余的空闲线程等待新任务的最长时间。
unit - keepAliveTime 参数的时间单位。
workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute方法提交的 Runnable任务。
threadFactory - 执行程序创建新线程时使用的工厂。
handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。
ThreadPoolExecutor是Executors类的底层实现。
主要注意的corePoolSize&＃xff0c;maximumPoolSize&＃xff0c;workQueue这三个概念&＃xff0c;后面会讲. 

6.3.2 线程池与队列搭配的使用策略。

了解了线程池和队列概念&＃xff0c;下面就是如何使用它们的问题。先看一下所有线程池和队列在使用时的原则&＃xff1a;

1)如果运行的线程少于 corePoolSize&＃xff0c;则 Executor始终首选添加新的线程&＃xff0c;而不进行排队。&＃xff08;如果当前运行的线程小于corePoolSize&＃xff0c;则任务根本不会存放&＃xff0c;添加到queue中&＃xff0c;而是直接抄家伙&＃xff08;thread&＃xff09;开始运行&＃xff09;
2)如果运行的线程等于或多于 corePoolSize&＃xff0c;则 Executor始终首选将请求加入队列&＃xff0c;而不添加新的线程。
3)如果无法将请求加入队列&＃xff0c;则创建新的线程&＃xff0c;除非创建此线程超出 maximumPoolSize&＃xff0c;在这种情况下&＃xff0c;任务将被拒绝。

6.3.3 了解原则后&＃xff0c;再看一下在这种原则上&＃xff0c;线程池和队列的三种常见搭配&＃xff1a;

1)直接提交
工作队列的默认选项是 SynchronousQueue&＃xff0c;它将任务直接提交给线程而不保持它们。在此&＃xff0c;如果不存在可用于立即运行任务的线程&＃xff0c;则试图把任务加入队列将失败&＃xff0c;因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。这里SynchronousQueue可看作它的长度为0
2)无界队列
使用无界队列&＃xff08;例如&＃xff0c;不具有预定义容量的 LinkedBlockingQueue&＃xff09;将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样&＃xff0c;创建的线程就不会超corePoolSize。&＃xff08;因此&＃xff0c;maximumPoolSize的值也就无效了。&＃xff09;当每个任务完全独立于其他任务&＃xff0c;即任务执行互不影响时&＃xff0c;适合于使用无界队列&＃xff1b;例如&＃xff0c;在 Web页服务器中。这种排队可用于处理瞬态突发请求&＃xff0c;当命令以超过队列所能处理的平均数连续到达时&＃xff0c;此策略允许无界线程具有增长的可能性
3)有界队列
当使用有限的 maximumPoolSizes时&＃xff0c;有界队列&＃xff08;如 ArrayBlockingQueue&＃xff09;有助于防止资源耗尽&＃xff0c;但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷&＃xff1a;使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销&＃xff0c;但是可能导致人工降低吞吐量。如果任务频繁阻塞&＃xff08;例如&＃xff0c;如果它们是 I/O边界&＃xff09;&＃xff0c;则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小&＃xff0c;CPU使用率较高&＃xff0c;但是可能遇到不可接受的调度开销&＃xff0c;这样也会降低吞吐量。
针对上面三种策略&＃xff0c;系统已经有预设置的搭配(设置好最合适的线程池大小和队列大小)&＃xff0c;能够处理常见的应用场景&＃xff1a; 
直接提交-->newScheduledThreadPool 创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
无界队列-->newCachedThreadPool
有界队列-->newFixedThreadPool
除此之外&＃xff0c;还有newSingleThreadExecutor&＃xff0c;创建一个单线程的线程池&＃xff0c;用来支持串行的任务。
这四种实现都是由Executors内的工厂方法产生的&＃xff0c;而且JDK文档中强烈建议使用。

6.4.线程池的使用
直接拿来使用即可&＃xff0c;关键是分析业务场景&＃xff0c;从上面四种已有实现中选择最合适的

public class MultiThread {public static void main(String[] args) {/*创建一个可重用固定线程数的线程池*/ExecutorService executorService &＃61; Executors.newFixedThreadPool(2);/*创建实现了Runnable接口对象*/MyThread t1 &＃61; new MyThread();MyThread t2 &＃61; new MyThread();MyThread t3 &＃61; new MyThread();MyThread t4 &＃61; new MyThread();MyThread t5 &＃61; new MyThread();/*将线程放入池中进行执行*/executorService.execute(t1);executorService.execute(t2);executorService.execute(t3);executorService.execute(t4);executorService.execute(t5);/*关闭线程池*/executorService.shutdown();}
}

7.总结

基本总结了多线程和线程池本质&＃xff0c;它们的优点和带来的缺点&＃xff1b;后面就开始讲述多线程在"除cpu外的资源的访问顺序"(文章中提到过&＃xff0c;这是多线程带来优点的同时&＃xff0c;需要解决的问题)多线程带来)方面的详细语法。