来谈谈多线程，线程的创建，

多线程

-1 高并发

参考文章： 【多线程高并发编程】二 实现多线程的几种方式

〇、使用多线程的场景

1. 为什么使用多线程

通俗的解释一下多线程先：

多线程用于堆积处理，就像一个大土堆，一个推土机很慢，那么10个推土机一起来处理，当然速度就快了，不过由于位置的限制，如果20个推土机，那么推土机之间会产生相互的避让，相互摩擦，相互拥挤，反而不如10个处理的好，所以，多线程处理，线程数要开的恰当，就可以提高效率。

多线程使用的目的：

1、吞吐量：做WEB，容器帮你做了多线程，但是它只能帮你做请求层面的，简单的说，就是一个请求一个线程(如struts2，是多线程的，每个客户端请求创建一个实例，保证线程安全)，或多个请求一个线程，如果是单线程，那只能是处理一个用户的请求。

2、伸缩性：通过增加CPU核数来提升性能。

多线程的使用场景：

1、常见的浏览器、Web服务(现在写的web是中间件帮你完成了线程的控制)，web处理请求，各种专用服务器(如游戏服务器)

2、servlet多线程

3、FTP下载，多线程操作文件

4、数据库用到的多线程

5、分布式计算

6、tomcat，tomcat内部采用多线程，上百个客户端访问同一个WEB应用，tomcat接入后就是把后续的处理扔给一个新的线程来处理，这个新的线程最后调用我们的servlet程序，比如doGet或者dpPost方法

7、后台任务：如定时向大量(100W以上)的用户发送邮件；定期更新配置文件、任务调度(如quartz)，一些监控用于定期信息采集

8、自动作业处理：比如定期备份日志、定期备份数据库

9、异步处理：如发微博、记录日志

10、页面异步处理：比如大批量数据的核对工作(有10万个手机号码，核对哪些是已有用户)

11、数据库的数据分析(待分析的数据太多)，数据迁移

12、多步骤的任务处理，可根据步骤特征选用不同个数和特征的线程来协作处理，多任务的分割，由一个主线程分割给多个线程完成

1. 线程概述

1.1 线程和进程

​ 进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。

线程也被称为轻量级进程，线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量，但不拥有系统资源，它与父进程的其它线程共享该进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

1.2 并发和并行

​ 并行指在同一时刻，有多条指令在多个处理器上同时执行；并发指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。

1.3 多线程的优势

（1）进程之间不能共享内存，但线程之间共享内存却非常容易。

（2）系统创建进程时需要为该进程重新分配系统资源，但创建线程代价小得多，因此使用多线程来实现多任务并发比多进程的效率高。

（3）java语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了java的多线程编程。

1.4 程序运行原理

​ 分时调度：

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

​ 抢占式调度：

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

1.5 主线程

​ jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。当程序的主线程执行时，如果遇到了循环而导致程序在指定位置停留时间过长，则无法马上执行下面的程序，需要等待循环结束后能够执行。

1.6 线程的 6 种状态

就像生物从出生到长大、最终死亡的过程一样，线程也有自己的生命周期，在 Java 中线程的生命周期中一共有 6 种状态。

• New（新创建）

• Runnable（可运行）

• Blocked（被阻塞）

• Waiting（等待）

• Timed Waiting（计时等待）

• Terminated（被终止）

如果想要确定线程当前的状态，可以通过 getState() 方法，并且线程在任何时刻只可能处于 1 种状态。

运行状态可能会有阻塞：

2. 线程的创建和启动

2.1 Thread类

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流。Java使用县城执行体来表示这段流。

2.2创建线程有哪几种方法

2.2.1 继承Thread类，重写Run方法（其中Thread类本身也是实现了Runnable接口）

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
（2）创建Thread子类的实例，即创建了线程对象。
（3）调用线程对象的start()方法来启动该线程。

示例代码：

package com.thread;
public class FirstThreadTest extends Thread{int i = 0;//重写run方法，run方法的方法体就是现场执行体public void run(){for(;i<100;i++){System.out.println(getName()+"  "+i);}}public static void main(String[] args){for(int i = 0;i< 100;i++){System.out.println(Thread.currentThread().getName()+"  : "+i);if(i==20){new FirstThreadTest().start();new FirstThreadTest().start();}}}
}

2.2.2 实现Runnable接口，重写run方法

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

（3）调用线程对象的start()方法来启动该线程。

示例代码：

public class RunnableThreadTest implements Runnable{private int i;public void run()	{for(i = 0;i <100;i++){System.out.println(Thread.currentThread().getName()+" "+i);}}public static void main(String[] args){for(int i = 0;i < 100;i++) {System.out.println(Thread.currentThread().getName()+" "+i);if(i==20) {RunnableThreadTest rtt = new RunnableThreadTest();new Thread(rtt,"新线程1").start();new Thread(rtt,"新线程2").start();}}}
}

2.2.3 实现 Callable 接口，重写 call方法（有返回值）

通过Callable和Future创建线程

（1）创建Callable接口的实现类，并实现**call()方法，该call()**方法将作为线程执行体，并且有返回值。

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的**call()**方法的返回值。

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

实例代码：

package com.thread;import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;public class CallableThreadTest implements Callable<Integer> {public static void main(String[] args) {CallableThreadTest ctt = new CallableThreadTest();FutureTask<Integer> ft = new FutureTask<>(ctt);for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName() + " 的循环变量i的值" + i);if (i == 20) {new Thread(ft, "有返回值的线程").start();}}try {System.out.println("子线程的返回值：" + ft.get());} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}@Overridepublic Integer call() throws Exception {int i = 0;for (; i < 100; i++) {System.out.println(Thread.currentThread().getName() + " " + i);}return i;}}

2.2.4 通过线程池创建线程

创建线程的三种方式的对比

1. 采用实现Runnable、Callable接口的方式创见多线程时
   优势：
   线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。
   在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
   劣势：
   编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。
2. 使用继承Thread类的方式创建多线程时
   优势：
   编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。
   劣势：
   线程类已经继承了Thread类，所以不能再继承其他父类。

4 线程池的核心参数有哪些：

为什么使用线程池？

使用线程池最大的原因就是可以根据系统的需求和硬件环境灵活的控制线程的数量,且可以对所有线程进行统一的管理和控制,从而提高系统的运行效率,降低系统运行运行压力;当然了,使用线程池的原因不仅仅只有这些,我们可以从线程池自身的优点上来进一步了解线程池的好处;

使用线程池的优势有哪些？

1. 线程和任务分离,提升线程重用性;
2. 控制线程并发数量,降低服务器压力,统一管理所有线程;
3. 提升系统响应速度,假如创建线程用的时间为T1，执行任务用的时间为T2,销毁线程用的时间为T3，那么使用线程池就免去了T1和T3的时间；

构造方法:
public ThreadPoolExecutor(int corePoolSize, //核心线程数量int maximumPoolSize,//     最大线程数long keepAliveTime, //       最大空闲时间TimeUnit unit,         //        时间单位BlockingQueue<Runnable> workQueue,   //   任务队列ThreadFactory threadFactory,    // 线程工厂RejectedExecutionHandler handler  //  饱和处理机制) 
{ ... }

4个参数的设计:

1:核心线程数(corePoolSize)
核心线程数的设计需要依据任务的处理时间和每秒产生的任务数量来确定,例如:执行一个任务需要0.1秒,系统百分之80的时间每秒都会产生100个任务,那么要想在1秒内处理完这100个任务,就需要10个线程,此时我们就可以设计核心线程数为10;当然实际情况不可能这么平均,所以我们一般按照8020原则设计即可,既按照百分之80的情况设计核心线程数,剩下的百分之20可以利用最大线程数处理;
2:任务队列长度(workQueue)
任务队列长度一般设计为:核心线程数/单个任务执行时间*2即可;例如上面的场景中,核心线程数设计为10,单个任务执行时间为0.1秒,则队列长度可以设计为200;
3:最大线程数(maximumPoolSize)
最大线程数的设计除了需要参照核心线程数的条件外,还需要参照系统每秒产生的最大任务数决定:例如:上述环境中,如果系统每秒最大产生的任务是1000个,那么,最大线程数=(最大任务数-任务队列长度)*单个任务执行时间;既: 最大线程数=(1000-200)*0.1=80个;
4:最大空闲时间(keepAliveTime)
这个参数的设计完全参考系统运行环境和硬件压力设定,没有固定的参考值,用户可以根据经验和系统产生任务的时间间隔合理设置一个值即可;