目录
一、多线程
1. 概述
现代操作系统（Windows，macOS，Linux）都可以执行多任务。多任务就是同时运行多个任务。例如：播放音乐的同时，浏览器可以进行文件下载，同时可以进行QQ消息的收发。
CPU执行代码都是一条一条顺序执行的，但是，即使是单核CPU，也可以同时运行多个任务。因为操作系统执行多任务实际上就是让CPU对多个任务轮流交替执行。
操作系统轮流让多个任务交替执行，例如，让浏览器执行0.001秒，让QQ执行0.001秒，再让音乐播放器执行0.001秒。在用户使用的体验看来，CPU就是在同时执行多个任务。
2. 进程与线程
2.1 程序
程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，可以理解为程序是包含静态代码的文件。例如：浏览器软件、音乐播放器软件等软件的安装目录和文件。
2.2 进程
进程是程序的一次执行过程，是系统运行程序的基本单位。在Windows系统中，每一个正在执行的exe文件或后台服务，都是一个进程，由操作系统统一管理并分配资源，因此进程是动态的。 例如：正在运行中的浏览器就是一个进程，正在运行中的音乐播放器是另一个进程，同理，正在运行中的QQ和WPS等都是进程。
操作系统运行一个程序，即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着， 同时，每个进程还占有某些系统资源如 CPU时间，内存空间，文件，输入输 出设备的使用权等。
2.3 线程
某些进程内部还需要同时执行多个子任务。例如，我们在使用WPS时，WPS可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行自动保存和上传云文档，我们把子任务称为线程。线程是进程划分成的更小的运行单位。
进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个主线程。
2.4 进程与线程的区别
- 根本区别：进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位；
- 资源开销：每个进程都有独立的代码副本和数据空间，进程之间的切换，资源开销较大；线程可以看做轻量级的进程，每个线程都有自己独立的运行栈和程序计数器，线程之间切换，资源开销小；
- 包含关系：一个进程内包含有多个线程，在执行过程，线程的执行不是线性串行的，而是多条线程并行共同完成；
- 内存分配：同一进程内的所有线程共享本进程的内存空间和资源；进程之间的内存空间和资源相互独立；
- 影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响；一个线程崩溃，会导致整个进程退出。所以多进程要比多线程健壮；
- 执行过程：每个独立的进程有程序运行的入口和程序出口。但是线程不能独立执行，必须依存在应用程序（进程）中，由应用程序提供多个线程执行控制；
3. 线程基本概念
单线程：单线程就是进程中只有一个线程。单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行。
public static void main(String[] args) { int a =10; int b =20; int c=a+b; System.out.println(c); }多线程：由一个以上的线程组成的程序称为多线程程序。Java中，一定是从主线程开始执行（main方法），然后在主线程的某个位置创建并启动新的线程。
作用：最主要是为了提高程序的运行效率
多线程应用场景：软件中耗时的操作 拷贝,迁移文件,加载大量的时候
为什么要有多线程？
线程:操作系统能够进行调度的最小单元,他被包含在进程中,是进程中实际运行的单位
进程:进程是程序的基本执行实体
4.并发与并行
并发:在同一时刻,有多个指令在单个Cpu上交替执行
并行:在同一时刻,有多个指令在单个Cpu上同时执行
5. 线程的创建方式
方式一：继承Thread类
继承 java.lang.Thread 类（线程子类）
创建多线程的方法1:
- 自定义一个类继承Thread
- 重写run方法
- 创建子类的对象,并启动线程
MyThread类：
public class MyThread extends Thread { public MyThread() { super(); } @Override public void run() { //写线程要执行的代码 for (int i = 0; i < 100; i++) { System.out.println(getName()+"_hello"); } } }Demo01类：
public class Demo01 { public static void main(String[] args) { /** *创建多线程的方法1: *1.自定义一个类继承Thread *2.重写run方法 *3.创建子类的对象,并启动线程 */ MyThread t1 = new MyThread(); t1.setName("线程1");//给线程设置名称 t1.start();//此处需要注意,不能直接调用run方法,否则就是对象的创建和方法的调用 MyThread t2 = new MyThread(); t2.setName("线程2"); t2.start(); for (int i = 0; i < 15; i++) { System.out.println(Thread.currentThread().getName()+"_world"); } } }
方式二：实现Runable接口
实现 java.lang.Runnable 接口（线程执行类）
创建多线程的方法2:
- 自己定义一个类实现Runable接口
- 重写里面的run方法
- 创建自己的类的对象
- 创建Thread类的对象,并开启线程
MyRun类：
public class MyRun implements Runnable { @Override public void run() { // 写线程要执行的代码 for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + "_hello"); } } }Demo02类：
public class Demo02 { public static void main(String[] args) { /** * 1.自己定义一个类实现Runable接口 2.重写里面的run方法 3.创建自己的类的对象 4.创建Thread类的对象,并开启线程 */ // 创建MyRun多线程,标识多线程要执行的任务 MyRun run = new MyRun(); // 创建线程 Thread t1 = new Thread(run); Thread t2 = new Thread(run); t1.setName("线程1"); t2.setName("线程2"); t1.start(); t2.start(); } }
方式三：实现Callable接口
实现 java.util.concurrent.Callable 接口，允许子线程返回结果、抛出异常
创建多线程的方法3:
- 创建Callable是实现类
- 重写ca11方法
- 创建Mycal1实现类的对象
- 创建FutureTask的对象(管理多线程运行的结果)
- 创建Thread对象,并启动
MyCall类：
public class MyCall implements Callable<Integer>{ //求1-100之间的和 @Override public Integer call() throws Exception { int sum = 0; for (int i = 1; i <= 100; i++) { sum+=i; } return sum; } }Demo03类：
public class Demo03 { public static void main(String[] args) throws InterruptedException, ExecutionException { /** * 1.创建Callable是实现类 * 2.重写ca11方法 * 3.创建Mycal1实现类的对象 * 4.创建FutureTask的对象(管理多线程运行的结果) * 5.创建Thread对象,并启动 */ MyCall call1 = new MyCall(); FutureTask<Integer> ft = new FutureTask<Integer>(call1); Thread t1 = new Thread(ft); t1.start(); //获取多线程运行后的结果 Integer result = ft.get(); System.out.println(result);
方式四：线程池
线程池（见五、线程池）
小结:
继承Thread类
优点：编程比较简单,可以直接使用Thread类中的方法,
缺点：可扩展性比较差,不能再继承其他的类
实现Runable接口优点：扩展性强,实现该接口后还可以同时继承其他类,实现其他的接口
缺点：编程相对比较复杂,不能直接使用Thread类中的方法
实现Callable接口优点：有返回值,可以利用FutureTask进行结果的保存
缺点：编程相对比较复杂,不能直接使用Thread类中的方法
注意：直接调用Thread实例的run()方法是无效的，因为直接调用run()方法，相当于调用了一个普通的Java方法，当前线程并没有任何改变，也不会启动新线程。
二、ThreadMethod
1. Thread类常用的构造方法
public class MyThread extends Thread { public MyThread() { super(); } public MyThread(String name) { super(name); } @Override public void run() { for (int i = 0; i < 20; i++) { try { sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(getName() + "@" + i); } } }Thread类常用的构造方法: Thread() Thread(String name) Thread(Runnable run,String name, Thread(Runnable run)MyThread t1 = new MyThread(); // 通过构造方法创建线程 MyThread t2 = new MyThread("线程2");
2. 线程的命名
生产环境中，为了排查问题方便，建议在创建线程的时候指定一个合理的线程名字
- 调用父类的setName()方法或在构造方法中给线程名字赋值；
// getName():获取线程名称 // 细节:如果给线程没有设置名称,线程也有默认的名称 Thread-x(从0开始) // setName()设置线程的名称构造方法也可以设置线程的名称 MyThread t1 = new MyThread(); t1.setName("线程1");
- 如果没有为线程命名，系统会默认指定线程名，命名规则是Thread-N的形式
3. 获取当前线程
Thread.currentThread()
// Thread.currentThread()获取当前线程对象 Thread tmain = Thread.currentThread(); tmain.setName("核心线程"); for (int i = 0; i < 20; i++) { System.out.println(tmain.getName() + "@" + i); }
4. 线程的休眠（暂停）
在线程中，可以通过调用Thread.sleep(long millis)，强迫当前线程按照指定毫秒值休眠。
public class Main { public static void main(String[] args) { System.out.println("main start..."); Thread t = new Thread() { public void run() { System.out.println("thread run..."); try { Thread.sleep(10); // 子线程休眠10毫秒 } catch (InterruptedException e) {} System.out.println("thread end."); } }; t.start(); try { Thread.sleep(20); // 主线程休眠20毫秒 } catch (InterruptedException e) {} System.out.println("main end..."); } }
5. 线程的优先级
- 在线程中，通过setPriority(int n)设置线程优先级，范围是1-10，默认为 5
- 优先级高的线程被操作系统调度的优先级较高（操作系统对高优先级线程，调度更频繁）
- 注意：并不能代表，通过设置优先级来确保高优先级的线程一定会先执行
- 案例：
public static void main(String[] args) { //创建一个匿名内部类对象run Runnable run = new Runnable() { @Override public void run() { for (int i = 0; i < 20; i++) { System.out.println(Thread.currentThread().getName() + "@" + i); } } }; Thread t1 = new Thread(run, "线程1"); Thread t2 = new Thread(run, "线程2"); //获取线程的优先级：默认为5 System.out.println(t1.getPriority()); System.out.println("线程t2的优先级为" + t2.getPriority()); System.out.println("主的优先级为：" + Thread.currentThread().getPriority()); //设置优先级，优先级的取值范围1-10之间，优先级越高，抢到的线程概率越大，但并不是绝对的 t1.setPriority(10); t2.setPriority(1); t1.start(); t2.start(); }
6. 守护线程（Daemon Thread）
用户线程与守护线程的区别
- 用户线程：我们平常创建的普通线程；
- 守护线程：用来服务于用户线程的线程，在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出；而守护线程执行结束后，虚拟机不会自动退出。
设置守护线程
守护线程:备胎线程--setDaemon(true)
细节:当其他的非守护的线程执行完毕后，守护线程会陆续结束
即(当女神线程结束，那么备胎线程也没有存在的必要)在调用start()方法前，调用setDaemon(true)把该线程标记为守护线程
public static void main(String[] args) { //守护线程:备胎线程--setDaemon(true) //细节:当其他的非守护的线程执行完毕后，守护线程会陆续结束 //即(当女神线程结束，那么备胎线程也没有存在的必要) //创建线程1 Thread t1 = new Thread() { @Override public void run() { for (int i = 1; i <=10; i++) { System.out.println(getName()+"@"+i); } }; }; //创建线程2 Thread t2 = new Thread() { @Override public void run() { for (int i = 1; i <=100; i++) { System.out.println(getName()+"@"+i); } }; }; //给线程设置名称 t1.setName("女神"); t2.setName("备胎"); //将第二个线程设置为守护线程 t2.setDaemon(true); t1.start(); t2.start(); }
7. 线程的让出：yield( )方法
线程通过调用yield()方法告诉JVM的线程调度，当前线程愿意让出CPU给其他线程使用。
○至于系统是否采纳，取决于JVM的线程调度模型：分时调度模型和抢占式调度模型
- 分时调度模型：所有的线程轮流获得 cpu的使用权,并且平均分配每个线程占用的 CPU 时间片；
- 抢占式调度模型：优先让可运行池中优先级高的线程占用 CPU，如果可运行池中的线程优先级相同，那么就随机选择一个线程，使其占用CPU。（JVM虚拟机采用的是抢占式调度模型 ）
public class MyThread1 extends Thread { //当前线程让出执行权后，再次进行抢夺也可能会抢夺到相关资源 @Override public void run() { for (int i = 1; i <= 100; i++) { System.out.println(getName() + "@" + i); //表示让出当前的cpu的执行权，会让结果更加均匀一点，但是并非绝对 Thread.yield();//出让线程，礼让线程 } } }public class Demo04 { public static void main(String[] args) { //创建线程1和线程2 //出让线程，礼让线程Thread.yield(); MyThread1 t1 = new MyThread1(); MyThread1 t2 = new MyThread1(); t1.setName("线程1"); t2.setName("线程2"); t1.start(); t2.start(); } }
8. 线程的插队：join( )方法
t.join()方法会使当前线程( 主线程 或者调用t.join()的线程 )进入等待池，并等待 线程t 执行完毕后才会被唤醒。此时，并不影响同一时刻处在运行状态的其他线程。
public class Demo05 { public static void main(String[] args) throws InterruptedException { //线程对象.join();插队线程 //此时土豆线程会和main线程抢占cpu的资源 //如果土豆先执行，后执行main就用到join方法 MyThread2 t1 = new MyThread2(); t1.setName("土豆"); t1.start(); //表示把t1线程插入到当前的线程前面 t1.join(); for (int i = 0; i <=100; i++) { System.out.println(Thread.currentThread().getName()+"@"+i); } } } class MyThread2 extends Thread { @Override public void run() { for (int i = 1; i <= 100; i++) { System.out.println(getName() + "@" + i); } } }
9. 小结
Thread线程的方法
- getName()--有默认的线程名
- setName()--给线程设置名称,构造方法也可以设置线程名
- Thread.currentThread(),获取当前线程
- getPriority() 获取线程的优先级1-10,默认的优先级为5
- setPriority(int) 数字越大优先级越大
- sleep(long mill) 睡眠
- join() 插队线程
- yield() 礼让线程
- setDaemon(boolean) 守护线程
三、线程安全问题
多线程售票问题
public class MyThread extends Thread { //表示当前的变量提升到了类级别，所有的类共享此成员变量 static int ticket = 0; @Override public void run() { // 卖票 while (true) { if (ticket < 10) { try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } ticket++; System.out.println(getName() + "正在卖出第" + ticket + "张票"); } else { break; } } } }public class Demo01 { public static void main(String[] args) { //线程在进行执行的过程中，cpu的执行权随时都可能被其他线程给抢走 MyThread t1 = new MyThread(); MyThread t2 = new MyThread(); MyThread t3 = new MyThread(); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); //线程启动开始卖票 t1.start(); t2.start(); t3.start(); } }
当多个线程同时运行时，线程的调度由操作系统决定，程序本身无法决定。因此，任何一个线程都有可能在任何指令处被操作系统暂停，然后在某个时间段后继续执行。
这个时候，一个在单线程模型下不存在的问题就会发生：如果多个线程同时读写共享变量，会出现数据不一致的问题。
解决方案1
解放方案1:锁代码块:
synchronized(锁对象){//锁对象可以是任意类型对象，但是必须要保证多个线程使用同一个锁 操作的共享的数据资源 }默认下，锁是打开装填，有一个线程进来，锁自动关闭
里面的代码执行完毕，线程出来，锁自动打开public class MyThread extends Thread { // 表示当前的变量提升到了类级别，所有的类共享此成员变量 static int ticket = 0; //注意事项:锁对象要唯一 static Object obj = new Object(); @Override public void run() { // 卖票 while (true) { synchronized (obj) { if (ticket < 1000) { try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } ticket++; System.out.println(getName() + "正在卖出第" + ticket + "张票"); } else { break; } } } } }
解决方案2
解放方案2:锁方法:
修饰符 synchronized 返回值类型 方法名(){ 括号内写的是共享的资源 }1.特点:同步方法锁锁住的方法中的代码
2.特点:方法上面的锁不能自己指定,
实例方法:通过当前对象,作为“锁”
静态方法:通过当前类class字节码对象，作为“锁public class MyThread extends Thread { // 表示当前的变量提升到了类级别，所有的类共享此成员变量 static int ticket = 0; @Override public void run() { // 卖票 while (true) { if (Method()) { break; } } } public static synchronized boolean Method() { if (ticket < 100) { try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } ticket++; System.out.println(Thread.currentThread().getName() + "正在卖出第" + ticket + "张票"); } else { return true; } return false; } }
public class Demo02 { public static void main(String[] args) { //MyRun作为Thread线程的参数进行传值 MyRun run =new MyRun(); Thread t1 = new Thread(run,"线程1"); Thread t2 = new Thread(run,"线程2"); Thread t3 = new Thread(run,"线程3"); t1.start(); t2.start(); t3.start(); } } class MyRun implements Runnable{ static int ticket =0; @Override public void run() { while (true) { if (Method()) { break; } } } //此处锁对象为当前的对象 public static synchronized boolean Method() { if (ticket < 10000) { try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } ticket++; System.out.println(Thread.currentThread().getName() + "正在卖出第" + ticket + "张票"); } else { return true; } return false; } }
解决方案3
解放方案3:Lock锁 1.5:
可以手动开锁关锁
lock();加锁
unlock();解锁//Lock锁 1.5 //可以手动开锁关锁 //lock();加锁 //unlock();解锁 public class MyThread extends Thread { // 表示当前的变量提升到了类级别，所有的类共享此成员变量 static int ticket = 0; static Lock lock = new ReentrantLock(); @Override public void run() { while (true) { lock.lock(); try { if (ticket < 100) { ticket++; System.out.println(getName() + "正在卖出第" + ticket + "张票"); } else { break; } } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); }finally { lock.unlock(); } } } }
四、线程状态
在Java程序中，一个线程对象通过调用start()方法启动线程，并且在线程获取CPU时，自动执行run()方法。run()方法执行完毕，代表线程的生命周期结束。
●在整个线程的生命周期中，线程的状态有以下6种：
- New：新建状态，新创建的线程，此时尚未调用start()方法；
- Runnable：运行状态，运行中的线程，已经调用start()方法，线程正在或即将执行run()方法；
- Blocked：阻塞状态，运行中的线程，在等待竞争锁时，被阻塞，暂不执行；
- Waiting：等待状态，运行中的线程，因为join()等方法调用，进入等待；
- Timed Waiting：计时等待状态，运行中的线程，因为执行sleep(等待毫秒值)join(等待毫秒值)等方法，进入计时等待；
- Terminated：终止状态，线程已终止，因为run()方法执行完毕。
●当线程启动后，它可以在Runnable、Blocked、Waiting和Timed Waiting这几个状态之间切换，直到最后变成Terminated状态，线程终止
线程终止的原因有：
○线程正常终止：run()方法执行到return语句返回；
○线程意外终止：run()方法因为未捕获的异常导致线程终止；
○对某个线程的Thread实例调用stop()方法强制终止（宇宙超级无敌强烈不推荐）；
1. New：新建状态
新建状态:线程对象创建，还没有调用start方法的时候
//新建状态:线程对象创建，还没有调用start方法的时候 public class NewState { public static void main(String[] args) { Thread thread = new Thread() { @Override public void run() { System.out.println("正在执行某件任务"); }; }; System.out.println(thread.getState());//NEW } }
2. Runnable：运行状态
线程对象调用start()方法，处于等待CPU分配资源，running ready
//线程对象调用start()方法，处于等待CPU分配资源，running ready public class RunState { public static void main(String[] args) { Thread thread = new Thread() { @Override public void run() { System.out.println("正在执行某件任务"); }; }; thread.start(); System.out.println(thread.getState());// RUNNABLE } }
3. Terminated：终止状态
TERMINATED操作系统注销此
//TERMINATED操作系统注销此 public class TerminatedState { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread() { @Override public void run() { System.out.println("正在执行某件任务"); }; }; thread.start(); Thread.sleep(1000); System.out.println(thread.getState());//TERMINATED } }
4. Blocked：阻塞状态
运行中的线程，在等待竞争锁时，被阻塞，暂不执行
public class BlockedState { public static void main(String[] args) throws InterruptedException { Runnable run = new Runnable() { @Override public void run() { synchronized (this) { //死循环 while (true); } } }; //创建线程t1和t2,并启动线程 Thread t1 = new Thread(run, "t1"); Thread t2 = new Thread(run, "t2"); t1.start(); t2.start(); //让主线程睡眠1秒，目的想让t1和t2同时竞争一个锁 Thread.sleep(1000); System.out.println("t1 state" + t1.getState()); System.out.println("t2 state" + t2.getState()); } }
5. Timed Waiting：计时等待状态
运行中的线程，因为执行sleep(等待毫秒值)join(等待毫秒值)等方法，进入计时等待；
// wait() // notify() // notifyA11() //注意事项: //1.要和synchronized写在一起 //2.锁对象要和调用的对象保持一致 //TIMED WAITING计时等待 //执行sleep(1ong millis)等方法 不会释放锁资源 //执行wait(long millis)等方法 会释放所资源 // join(等待时间) public class TimeWaitingState { public static void main(String[] args) throws InterruptedException { Runnable run = new Runnable() { @Override public void run() { synchronized (this) { System.out.println(Thread.currentThread().getName()); try { // Thread.sleep(5000); this.wait(5000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }; Thread t1 = new Thread(run, "t1"); Thread t2 = new Thread(run, "t2"); // 期待线程，观察sleep方法和wait方法对比 t1.start(); t2.start(); // 让当前线程睡眠1秒 Thread.sleep(1000); // 获取线程状态 System.out.println(t1.getState()); System.out.println(t2.getState()); } }
//Object 类 // wait(long) // wait() //TIMED WAITING计时等待 //执行sleep(long millis)等方法 不会释放锁资源 //执行wait(long millis)等方法 会释放所资源 //执行 join(等待时间) public class TimeWaitingState02 { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread() { @Override public void run() { Thread t1 = new Thread() { @Override public void run() { System.out.println("t1线程"); }; }; t1.start(); //join方法会让当前的线程处于计时等待 try { t1.join(500 * 1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } }; }; thread.start(); Thread.sleep(1000); //查看thread线程的状态 System.out.println(thread.getState()); } }
6. Waiting：等待状态
运行中的线程，因为join()等方法调用，进入等待；
//WAITING 等待状态 wait() // join() //Oject中的wait() wait(long time) //1.synchronized写在一起 //2.锁对象要和调用的对象保持一致 public class WaitingState01 { public static void main(String[] args) throws InterruptedException { Object obj = new Object(); Thread t1 = new Thread() { public void run() { synchronized (obj) { try { obj.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }; }; t1.start(); Thread.sleep(1000); System.out.println(t1.getState());//WAITING } }
//Oject中的wait() wait(long time) // 1.synchronized写在一起 // 2.锁对象要和调用的对象保持一致 public class WaitingState02 { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread() { @Override public void run() { while (true) ; } }; t1.start(); t1.join();//t1加到当前的主线程的前面，主线程一直处于等待状态 //获取不到，因为当前的主线程被t1线程插队,t1线程任务是个死循环，无法结束 System.out.println(Thread.currentThread().getState()); } }
五、线程池
1. 什么是线程池？
线程池内部维护了若干个线程，没有任务的时候，这些线程都处于等待空闲状态。如果有新的线程任务，就分配一个空闲线程执行。如果所有线程都处于忙碌状态，线程池会创建一个新线程进行处理或者放入队列（工作队列）中等待。
线程池：线程池是一个可以复用线程的技术
2. 线程池常用类和接口
在Java标准库提供了如下几个类或接口，来操作并使用线程池：
- ExecutorService接口：进行线程池的操作访问；
- Executors类：创建线程池的工具类；
- ThreadPoolExecutor及其子类：封装线程池的核心参数和运行机制；
MyRunable类：
public class MyRunable implements Runnable { public MyRunable() { } public MyRunable(String name) { } @Override public void run() { // TODO Auto-generated method stub } }线程池的基本使用方式：
//线程池：线程池是一个可以复用线程的技术 //1. ExecutorService接口：进行线程池的操作访问； // submit() // execute() //2. Executors类：创建线程池的工具类； // Executors.newCachedThreadPool() 创建一个线程没有上线的线程池 //3. ThreadPoolExecutor及其子类：封装线程池的核心参数和运行机制； public class Demo01 { public static void main(String[] args) throws InterruptedException { // 创建一个线程没有上限的线程池 ExecutorService pool1 = Executors.newCachedThreadPool(); // 线程池提交任务 pool1.execute(new MyRunable()); // Thread.sleep(1000); pool1.execute(new MyRunable()); // Thread.sleep(1000); pool1.execute(new MyRunable()); // Thread.sleep(1000); pool1.execute(new MyRunable()); // 销毁线程--用完后线程池给砸了 pool1.shutdown(); } }
3. 线程池常见方法
- 执行无返回值的线程任务：void execute(Runnable command);
- 提交有返回值的线程任务：Future<T> submit(Callable<T> task);
- 关闭线程池：void shutdown(); 或 shutdownNow();
- 等待线程池关闭：boolean awaitTermination(long timeout, TimeUnit unit);
执行线程任务
execute()只能提交Runnable类型的任务，没有返回值，而submit()既能提交Runnable类型任务也能提交Callable类型任务，可以返回Future类型结果，用于获取线程任务执行结果。
execute()方法提交的任务异常是直接抛出的，而submit()方法是捕获异常，当调用Future的get()方法获取返回值时，才会抛出异常。//线程池：线程池是一个可以复用线程的技术 //1. ExecutorService接口：进行线程池的操作访问； // submit()--提交任务 Runable Callable // execute()--提交任务Runable //2. Executors类：创建线程池的工具类； // Executors.newCachedThreadPool() 创建一个线程没有上限的线程池 // Executors.newFixedThreadPool(int nThreads) 创建一个有上限的线程池 //3. ThreadPoolExecutor及其子类：封装线程池的核心参数和运行机制； public class Demo02 { public static void main(String[] args) { // Executors.newFixedThreadPool(int nThreads) 创建一个有上限的线程池 ExecutorService pool = Executors.newFixedThreadPool(5); pool.submit(new MyRunable("任务1")); pool.submit(new MyRunable("任务2")); pool.submit(new MyRunable("任务3")); pool.submit(new MyRunable("任务4")); } }
MyCallable类：
public class MyCallable implements Callable<Integer>{ private int number; public MyCallable(int number) { this.number = number; } @Override public Integer call() throws Exception { int sum = 0; for (int i = 0; i <= number ; i++) { sum+=i; } return sum; } }//线程池：线程池是一个可以复用线程的技术 //1. ExecutorService接口：进行线程池的操作访问； // submit()--提交任务 Runable Callable // execute()--提交任务Runable //2. Executors类：创建线程池的工具类； // Executors.newCachedThreadPool() 创建一个线程没有上线的线程池 // Executors.newFixedThreadPool(int nThreads) 创建一个有上线的线程池 // 核心线程数量到底配置多少：计算密集型任务: =CPU的核数+1; IO密集型任务: CPU的核数*2 //3. ThreadPoolExecutor及其子类：封装线程池的核心参数和运行机制； public class Demo03 { public static void main(String[] args) throws InterruptedException, ExecutionException { // 创建一个有上线的线程的线程池 ExecutorService pool = Executors.newFixedThreadPool(5); //测试submit的方法--传callable值 Future<Integer> futureTask1 = pool.submit(new MyCallable(10)); Future<Integer> futureTask2 = pool.submit(new MyCallable(100)); Future<Integer> futureTask3 = pool.submit(new MyCallable(1000)); System.out.println(futureTask1.get());//55 System.out.println(futureTask2.get());//5050 System.out.println(futureTask3.get());//500500 } }
4. 线程池分类总结
FixedThreadPool
线程数固定的线程池
线程池参数：
- 核心线程数和最大线程数一致
- 非核心线程线程空闲存活时间，即keepAliveTime为0
- 阻塞队列为无界队列LinkedBlockingQueue
工作机制：
- 提交线程任务
- 如果线程数少于核心线程，创建核心线程执行任务
- 如果线程数等于核心线程，把任务添加到LinkedBlockingQueue阻塞队列
- 如果线程执行完任务，去阻塞队列取任务，继续执行
使用场景： 适用于处理CPU密集型的任务，确保CPU在长期被工作线程使用的情况下，尽可能的少的分配线程，即适用执行长期的任务。
CachedThreadPool
可缓存线程池，线程数根据任务动态调整的线程池
线程池参数：
- 核心线程数为0
- 最大线程数为Integer.MAX_VALUE
- 工作队列是SynchronousQueue同步队列
- 非核心线程空闲存活时间为60秒
●工作机制：
- 提交线程任务
- 因为核心线程数为0，所以任务直接加到SynchronousQueue工作队列
- 判断是否有空闲线程，如果有，就去取出任务执行
- 如果没有空闲线程，就新建一个线程执行
- 执行完任务的线程，还可以存活60秒，如果在这期间，接到任务，可以继续存活下去；否则，被销毁。
使用场景： 用于并发执行大量短期的小任务。
SingleThreadExecutor
单线程化的线程池
线程池参数：
- 核心线程数为1
- 最大线程数也为1
- 阻塞队列是LinkedBlockingQueue
- 非核心线程空闲存活时间为0秒
使用场景： 适用于串行执行任务的场景，将任务按顺序执行。
ScheduledThreadPool
能实现定时、周期性任务的线程池
线程池参数：
- 最大线程数为Integer.MAX_VALUE
- 阻塞队列是DelayedWorkQueue
- keepAliveTime为0
使用场景： 周期性执行任务，并且需要限制线程数量的需求场景。
//线程池：线程池是一个可以复用线程的技术 //1. ExecutorService接口：进行线程池的操作访问； // submit() // execute() //2. Executors类：创建线程池的工具类； // Executors.newCachedThreadPool() 创建一个线程没有上线的线程池，如果任务执行完线程空闲60秒会被回收 // Executors.newFixedThreadPool(int nThreads) 创建一个有上线的线程池 // Executors.newSingleThreadExecutor()创建一个只有一个线程的线程池对象 // Executors.newScheduledThreadPool() 创建一个线程池，可以实现在给时间延后执行或者定期执行任务 //3. ThreadPoolExecutor及其子类：封装线程池的核心参数和运行机制； public class Demo04 { public static void main(String[] args) { // 创建只有一个线程的线程池 // ExecutorService pool=Executors.newSingleThreadExecutor(); // pool.submit(new MyRunable("任务1")); // pool.submit(new MyRunable("任务2")); //1.创建任务调度线程池对象 ScheduledExecutorService pool1=Executors.newScheduledThreadPool(2); Runnable run = new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()); } }; //提交任务，延时5秒执行 // pool1.schedule(run,5,TimeUnit.SECONDS); //提交任务，延时5秒，以后每1秒执行1次 pool1.scheduleAtFixedRate(run, 5, 1,TimeUnit.SECONDS); } }
5. 线程池的配置参数
●corePoolSize线程池核心线程数：也可以理解为线程池维护的最小线程数量，核心线程创建后不会被回收。大于核心线程数的线程，在空闲时间超过keepAliveTime后会被回收；
- 在创建了线程池后，默认情况下，线程池中并没有任何线程，当调用 execute() 方法添加一个任务时，如果正在运行的线程数量小于corePoolSize，则马上创建新线程并运行这个任务。
- IO密集计算：由于 I/O 设备的速度相对于 CPU来说都很慢，所以大部分情况下，I/O 操作执行的时间相对于 CPU 计算来说都非常长，这种场景我们一般都称为 I/O 密集型计算。最佳线程数 =CPU 核数 * [ 1 +（I/O 耗时 / CPU 耗时）]。
- CPU密集型：CPU 密集型计算大部分场景下都是纯 CPU 计算，多线程主要目的是提升CPU利用率，最佳线程数 =“CPU 核心数 +1”。这样的话，当线程因为偶尔的内存页失效或其他原因导致阻塞时，这个额外的线程可以临时替补，从而保证 CPU 的利用率。
●maximumPoolSize线程池最大线程数：线程池允许创建的最大线程数量；（包含核心线程池数量）
●keepAliveTime非核心线程线程存活时间：当一个可被回收的线程的空闲时间大于keepAliveTime，就会被回收。
- 当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会被回收，直到线程池中的线程数不超过corePoolSize。
- 如果设置allowCoreThreadTimeOut = true，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
●TimeUnit时间单位：参数keepAliveTime的时间单位；
●BlockingQueue阻塞工作队列：用来存储等待执行的任务；
●ThreadFactory线程工厂 : 用于创建线程，以及自定义线程名称，需要实现ThreadFactory接口；
●RejectedExecutionHandler拒绝策略：当线程池线程内的线程耗尽，并且工作队列达到已满时，新提交的任务，将使用拒绝策略进行处理；
- ThreadPoolExecutor.AbortPolicy：默认策略，丢弃任务并抛出RejectedExecutionException异常；
- ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常；
- ThreadPoolExecutor.DiscardOldestPolicy：丢弃工作队列中的队头任务（即最旧的任务，也就是最早进入队列的任务）后，继续将当前任务提交给线程池；
- ThreadPoolExecutor.CallerRunsPolicy：由原调用线程处理该任务 （谁调用，谁处理）；
MyRun 类:
public class MyRun implements Runnable { private String name; public MyRun() { } public MyRun(String name) { this.name = name; } @Override public void run() { System.out.println(Thread.currentThread().getName()+ name + "======>" + "正在执行"); // 让任务稍微慢点，便于观察结果 try { Thread.sleep(Integer.MAX_VALUE); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }//线程池的创建方式2： // new ThreadPoolExecutor public class Demo01 { public static void main(String[] args) { // corePoolSize:线程核心数量 // maximumPoolSize:线程池中最大的线程数 // keepAliveTime：临时线程的存活时间 // unit,时间单位(时，分，秒) // workQueue, 任务队列 // threadFactory, 为线程池创建线程的线程工厂 // handler:指定线程池的拒绝策略 // 1.AbortPolicy--丢弃任务并抛出异常，默认拒绝策略 // 2.CallerRunsPolicy--由主线程负责调用run方法，绕过线程池 // 3.DiscardOldestPolicy--抛弃队列中等待最久的任务，把当前的任务加入到队列 // 4.DiscardPolicy--丢弃任务，不抛出异常，不推荐 ExecutorService pool = new ThreadPoolExecutor( 3, 6, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy()); // MyRun run = new MyRun(); pool.execute(new MyRun("任务1"));//提交第一个任务，线程池会自动创建一个新的线程，自动处理任务 pool.execute(new MyRun("任务2")); pool.execute(new MyRun("任务3")); pool.execute(new MyRun("任务4"));//提交第4个任务时候,进入等待队列中 pool.execute(new MyRun("任务5")); pool.execute(new MyRun("任务6")); pool.execute(new MyRun("任务7"));//提交第7个任务的时候，核心线程数已满，队列已满，再来新任务，看临时工 pool.execute(new MyRun("任务8"));// pool.execute(new MyRun("任务9")); pool.execute(new MyRun("任务10"));//核心线程满，队列满，临时满 pool.execute(new MyRun("任务11")); } }
//线程池的创建方式2： // new ThreadPoolExecutor public class Demo02 { public static void main(String[] args) throws InterruptedException, ExecutionException { // corePoolSize:线程核心数量 // maximumPoolSize:线程池中最大的线程数 // keepAliveTime：临时线程的存活时间 // unit,时间单位(时，分，秒) // workQueue, 任务队列 // threadFactory, 为线程池创建线程的线程工厂 // handler:指定线程池的拒绝策略 // 1.AbortPolicy--丢弃任务并抛出异常，默认拒绝策略 // 2.CallerRunsPolicy--由主线程负责调用run方法，绕过线程池 // 3.DiscardOldestPolicy--抛弃队列中等待最久的任务，把当前的任务加入到队列 // 4.DiscardPolicy--丢弃任务，不抛出异常，不推荐 ExecutorService pool = new ThreadPoolExecutor(3, 6, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy()); Future<Integer> f1=pool.submit(new MyCall(10)); Future<Integer> f2=pool.submit(new MyCall(20)); Future<Integer> f3=pool.submit(new MyCall(30)); System.out.println(f1.get()); System.out.println(f2.get()); System.out.println(f3.get()); } } class MyCall implements Callable<Integer> { private int number; public MyCall(int number) { this.number = number; } @Override public Integer call() throws Exception { int sum = 0; for (int i = 0; i <= number; i++) { sum += i; } return sum; } }
public class Demo03 { public static void main(String[] args) { // corePoolSize:线程核心数量 // maximumPoolSize:线程池中最大的线程数 // keepAliveTime：临时线程的存活时间 // unit,时间单位(时，分，秒) // workQueue, 任务队列 // threadFactory, 为线程池创建线程的线程工厂 // handler:指定线程池的拒绝策略 // 1.AbortPolicy--丢弃任务并抛出异常，默认拒绝策略 // 2.CallerRunsPolicy--由主线程负责调用run方法，绕过线程池 // 3.DiscardOldestPolicy--抛弃队列中等待最久的任务，把当前的任务加入到队列 // 4.DiscardPolicy--丢弃任务，不抛出异常，不推荐 ThreadPoolExecutor pool = new ThreadPoolExecutor( 3, 6, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3), new MyThreadFactory(), new ThreadPoolExecutor.DiscardPolicy()); // MyRun run = new MyRun(); pool.execute(new MyRun("任务1"));//提交第一个任务，线程池会自动创建一个新的线程，自动处理任务 pool.execute(new MyRun("任务2")); pool.execute(new MyRun("任务3")); ThreadPoolExecutor pool1 = new ThreadPoolExecutor( 3, 6, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3), new MyThreadFactory(), new ThreadPoolExecutor.DiscardPolicy()); // MyRun run = new MyRun(); pool1.execute(new MyRun("任务1"));//提交第一个任务，线程池会自动创建一个新的线程，自动处理任务 pool1.execute(new MyRun("任务2")); pool1.execute(new MyRun("任务3")); } } class MyThreadFactory implements ThreadFactory { private static final AtomicInteger poolNumber = new AtomicInteger(1); private final ThreadGroup group; private final AtomicInteger threadNumber = new AtomicInteger(1); private final String namePrefix; MyThreadFactory() { SecurityManager s = System.getSecurityManager(); group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup(); namePrefix = "池子-" + poolNumber.getAndIncrement() + "-线程-"; } public Thread newThread(Runnable r) { Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0); if (t.isDaemon()) t.setDaemon(false); if (t.getPriority() != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY); return t; } }
6. 线程池的执行流程
1. 提交一个新线程任务，线程池会在线程池中分配一个空闲线程，用于执行线程任务；
2. 如果线程池中不存在空闲线程，则线程池会判断当前“存活的线程数”是否小于核心线程数corePoolSize。
○如果小于核心线程数corePoolSize，线程池会创建一个新线程（核心线程）去处理新线程任务；
○如果大于核心线程数corePoolSize，线程池会检查工作队列；
■如果工作队列未满，则将该线程任务放入工作队列进行等待。线程池中如果出现空闲线程，将从工作队列中按照FIFO的规则取出1个线程任务并分配执行；
■如果工作队列已满，则判断线程数是否达到最大线程数maximumPoolSize；
●如果当前“存活线程数”没有达到最大线程数maximumPoolSize，则创建一个新线程（非核心线程）执行新线程任务；
●如果当前“存活线程数”已经达到最大线程数maximumPoolSize，直接采用拒绝策略处理新线程任务；
综上所述，执行顺序为：核心线程、工作队列、非核心线程、拒绝策略。
7. 线程池的状态
线程池的状态分为：RUNNING,SHUTDOWN,STOP,TIDYING,TERMINATED
○ RUNNING ： 运行状态，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0。该状态的线程池会接收新任务，并处理工作队列中的任务。
- 调用线程池的shutdown()方法，可以切换到SHUTDOWN关闭状态；
调用线程池的shutdownNow()方法，可以切换到STOP停止状态；
○SHUTDOWN：关闭状态，该状态的线程池不会接收新任务，但会处理工作队列中的任务；
- 当工作队列为空时，并且线程池中执行的任务也为空时，线程池进入TIDYING状态；
○STOP：停止状态，该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行 的任务；
- 线程池中执行的任务为空,进入TIDYING状态;
○TIDYING：整理状态，该状态表明所有的任务已经运行终止，记录的任务数量为0；
- terminated()执行完毕，进入TERMINATED状态；
○TERMINATED: 终止状态，该状态表示线程池彻底关闭。
191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
