多线程详解
- 进程与线程简介
- 创建线程
- 线程状态
- 线程同步
- 线程协作
- 线程池
进程与线程简介
-
进程（Process）：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——系统资源分配的最小单位。
-
线程（Thread）：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。
-
两者之间的区别见下图
可以发现，进程是由（线程+内存+文件/网络句柄）等元素构成的
-
注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。
-
普通方法调用和多线程
-
核心概念
- 线程就是独立的执行路径
- 在程序执行时，即使没有自己创建1线程，后台也会有多个线程，如主线程，gc线程(垃圾回收线程)。
- main()称之为主线程，为系统的入口，用于执行整个程序
- 在一个程序中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
- 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。
- 线程会带来额外的开销，如CPU调度时间；并发控制开销。
- 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。
创建线程
三种创建方式
-
继承Thread创建线程
- 自定义线程类继承Thread类
- 重写run()方法，编写线程执行体
- 创建线程对象，调用start()方法启动线程
创建TestThread01类，实现继承Thread类创建线程
package com.thread_; //创建线程类方式一：继承Thread类，重写run方法，在主线程调用start开启线程。 public class TestThread01 extends Thread{ //run方法线程体 @Override public void run() { for (int i = 0; i < 50; i++) { System.out.println("我在看代码！"+i); } } //主方法，main线程 public static void main(String[] args) { //创建一个线程对象 TestThread01 testThread01 = new TestThread01(); //调用start开启线程 testThread01.start(); for (int i = 0; i < 1000; i++) { System.out.println("我在学习线程"+i); } } }运行结果：
需要注意的是，线程开启不一定立即执行，由CPU的调度执行
-
实现多线程进行网络图片下载
首先我们需要引入commons-io包，并且把它导入到项目下的lib包中
再创建下载器WebDownLoader类用于下载网络图片
class WebDownLoader{ //下载方法 public void downLoader(String url,String name){ try { FileUtils.copyURLToFile(new URL(url),new File(name)); } catch (IOException e) { e.printStackTrace(); System.out.println("DownLoader方法出现异常"); } } }创建线程类TestThread02
package com.thread_; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; public class TestThread02 extends Thread{ //创建属性url与name，用于接收网络图片地址和保存文件名 private String url; private String name; //创建TestThread02的构造器 public TestThread02(String url,String name){ this.url = url; this.name = name; } //重写run方法，下载图片的线程执行体 @Override public void run() { WebDownLoader webDownLoader = new WebDownLoader(); webDownLoader.downLoader(url,name); System.out.println("DownLoader Image " + name); } public static void main(String[] args) { TestThread02 t1 = new TestThread02("https://github.com/minster77/minster77.github.io/blob/master/JavaBase.jpg","1.jpg"); TestThread02 t2 = new TestThread02("https://github.com/minster77/minster77.github.io/blob/master/JavaCollection.jpg","2.jpg"); TestThread02 t3 = new TestThread02("https://github.com/minster77/minster77.github.io/blob/master/JavaThink.jpg","3.jpg"); t1.start(); t2.start(); t3.start(); } }主目录下我们可以发现图片以及下载完成
而控制台也输出了以下结果
我们可以发现，三个图片并没有按照我们调用start方法的顺序下载完成。这就是我们所说的多线程执行了。
-
实现Runnable接口创建线程
- 定义一个实现类实现Runnable接口
- 实现run()方法，编写线程执行体
- 创建线程对象，调用start()方法启动线程
package com.thread_; public class TestThread03 implements Runnable{ //run方法线程体 @Override public void run() { for (int i = 0; i < 50; i++) { System.out.println("我在看代码！"+i); } } //主方法，main线程 public static void main(String[] args) { TestThread03 testThread03 = new TestThread03(); //下面两句等价于 new Thread(testThread03).start(); Thread thread = new Thread(testThread03); thread.start(); for (int i = 0; i < 1000; i++) { System.out.println("我在学习线程"+i); } } }其实实现Runnable接口创建线程与继承Thread类创建线程的方法步骤是一样的，但是由于继承Thread类创建是单继承，具有局限性。所以开始时推荐选择实现Runnable接口创建多线程
-
小结
继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程：子类对象.start()
- 不建议使用继承Thread类创建线程，因为面向对象单继承具有局限性
实现Runnable接口
- 实现Runnable具有多线程能力
- 启动线程：传入目标对象+Thread对象.start()
- 推荐使用Runnable接口创建线程，因为可以避免单继承局限性，灵活方便，方便同时一个对象被多个线程使用。
-
实现Callable接口创建线程
- 实现Callable接口，需要返回值类型
- 重写call方法，需要抛出异常
- 创建目标对象
- 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
- 提交执行：Futureresult1 = ser.submit(t1)；
- 获取结果：boolean r1 = result.get()
- 关闭服务：ser.shutdownNow()；
-
Callable的好处
- 可以定义返回值
- 可以返回异常
线程状态
-
线程具有五个状态，分别是创建状态、就绪状态、阻塞状态、运行状态、死亡状态。
关系图如下
线程状态转换细节
线程方法
- setPriority(int newPriority)：更改线程的优先级
- static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程体休眠
- void join()：等待该线程终止
- static void yield()：暂停当前正在执行的线程对象，并执行其他线程
- void interrupt()：中断线程。不建议使用！
- boolean isAlive()：测试线程是否处于活动状态
不建议使用JDK提供的stop()、destory()方法[已废弃！]。
推荐让线程自己停下来。
或者使用一个标志位进行终止变量，当flag=false时，则终止线程运行。
设置标志位让线程停止的代码演示：
package com.lambda; public class TestStop implements Runnable{ //1.设置一个标志位 private boolean flag = true; @Override public void run() { int i = 0; while (flag){ System.out.println("run Thread..."+i++); } } //2.设置一个对外提供的方法停止线程，转换标志位 private void stop(){ this.flag = false; } public static void main(String[] args) { TestStop testStop = new TestStop(); new Thread(testStop).start(); for (int i = 0; i < 1000; i++) { System.out.println("main = "+i); if (i==900){ //调用stop方法切换标志位，让线程停止； testStop.stop(); System.out.println("线程停止了！"); } } } } -
线程休眠
- sleep(time)指定当前线程阻塞的毫秒数；
- sleep存在异常InterruptedException
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延时，倒计时等。
- 每一个对象都有一个锁，sleep不会释放锁
模拟网络延时：可以放大问题的发生性。
模拟倒计时
package com.lambda; import java.text.SimpleDateFormat; import java.util.Date; public class TestSleep { public static void main(String[] args) throws InterruptedException { timeDown(); } public static void timeDown() { int n = 10; while (true){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(n--); if (n<=0){ break; } } } }打印出当前系统时间
package com.lambda; import java.text.SimpleDateFormat; import java.util.Date; public class TestSleep { public static void main(String[] args) throws InterruptedException { //获取系统当前时间 Date startDate = new Date(System.currentTimeMillis()); while (true){ Thread.sleep(1000); System.out.println(new SimpleDateFormat("HH:mm:ss").format(startDate)); startDate = new Date(System.currentTimeMillis()); } } } -
线程礼让
- 线程礼让，让当前正在执行的线程暂停，但不阻塞
- 将线程从运行状态转为就绪状态，让CPU重新调度，礼让不一定成功！看CPU心情
创建测试类TestYield
package com.lambda; public class TestYield { public static void main(String[] args) { MyYield myYield = new MyYield(); new Thread(myYield,"a").start(); new Thread(myYield,"b").start(); } } class MyYield implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"线程开始了"); Thread.yield(); System.out.println(Thread.currentThread().getName()+"线程停止了"); } }礼让成功：
礼让失败：
-
Join方法：Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞。（就是强制插队，不建议使用！）
package com.lambda; public class TestJoin implements Runnable{ public static void main(String[] args) throws InterruptedException { TestJoin testJoin = new TestJoin(); Thread thread = new Thread(testJoin); thread.start(); for (int i = 0; i < 1000; i++) { if(i == 200){ thread.join(); } System.out.println("main = " + i); } } @Override public void run() { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } for (int i = 0; i < 100; i++) { System.out.println("我来插队了！"); } } }
-
观察测试线程的状态
package com.lambda; public class TestState { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(()->{ for (int i = 0; i < 5; i++) { try { //调用sleep方法，进入阻塞状态 Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("///////"); }); //调用getState方法，观察线程状态 Thread.State state = thread.getState(); System.out.println(state);//NEW thread.start(); state = thread.getState(); System.out.println(state);//RUNNABLE //只要线程不终止，就一直输出 while (state != Thread.State.TERMINATED){ Thread.sleep(100); state = thread.getState();//更新线程状态 System.out.println(state); } } }运行结果：
线程优先级
-
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
-
线程的优先级用数字表示，范围从1~10
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
-
使用以下方式可以改变或获取优先级
- getPriority()，setPriority(int xxx);
代码演示
package com.thread_; public class TestPriority { public static void main(String[] args) { //main线程的默认优先级为5 System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority()); MyPriority myPriority = new MyPriority(); Thread t1 = new Thread(myPriority); Thread t2 = new Thread(myPriority); Thread t3 = new Thread(myPriority); Thread t4 = new Thread(myPriority); Thread t5 = new Thread(myPriority); //优先级设定在start()调度前 //默认是5 t1.start(); t2.setPriority(3); t2.start(); t3.setPriority(6); t3.start(); t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY = 10; t4.start(); t5.setPriority(Thread.NORM_PRIORITY); t5.start(); } } class MyPriority implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority()); } }运行结果：
可以发现，优先级高的线程不一定先执行。
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了；这都是看CPU的调度的。（性能倒置）
守护线程
-
线程分为用户线程和守护线程
-
虚拟机必须确保用户线程执行完毕
-
虚拟机不用等待守护线程执行完毕
-
常见的守护现场有：后台记录操作日志，监控内存，垃圾回收等等…
-
测试守护线程
package com.thread_; public class TestDaemon { public static void main(String[] args) { God god = new God(); People people = new People(); Thread thread = new Thread(god); //默认false表示是用户线程，正常线程都是用户线程 //设置为true表示该线程为守护线程 thread.setDaemon(true); //启动守护线程 thread.start(); new Thread(people).start(); } } class God implements Runnable{ @Override public void run() { while (true){ System.out.println("上帝守护着你！"); } } } class People implements Runnable{ @Override public void run() { for (int i = 0; i < 36500; i++) { System.out.println("你开心的活着"); } System.out.println("GoodBye world"); } }
线程同步
并发问题的引出
-
并发：同一个对象被多个线程同时操作
-
当我们使用多线程操作一个对象时，容易发生并发问题，下面我们举一个买火车票的例子来引出并发问题
package com.thread_.syn; public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"jack").start(); new Thread(buyTicket,"tom").start(); new Thread(buyTicket,"mary").start(); } } class BuyTicket implements Runnable{ private int ticketNum = 10; private boolean flag =true; @Override public void run() { while (flag){ try { buy(); } catch (InterruptedException e) { e.printStackTrace(); } } } public void buy() throws InterruptedException { if(ticketNum<=0){ flag = false; return; } Thread.sleep(100); System.out.println(Thread.currentThread().getName() + "抢到了第" + ticketNum-- + "票"); } }运行结果：
我们可以发现，有一些票被重复拿了！多个线程操作一个资源的情况下，线程不安全，数据紊乱。这就是我们所说的线程并发问题。
利用线程的同步可以解决上述的问题！
-
线程同步介绍
由于统一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制-synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待；使用后释放锁即可。
使用锁会存在以下问题
- 一个线程持有锁会导致其他所有需要此锁的线程挂起
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。（性能倒置问题）
-
同步方法
-
由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制1就是synchronized关键字。它包括两种用法：synchronized方法和synchronized块
//同步方法 public synchronized void method(int args){ } -
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的锁才能执行，否则线程会阻塞。方法一旦执行，就独占该锁，知道该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
缺陷：若将一个大的方法申明为synchronized将会影响效率
-
方法里需要修改的内容才需要锁，锁太多了会浪费资源。
所以在上面买火车票的案例中，我们只需要对buy方法加上修饰符synchronized即可以解决并发问题！
public synchronized void buy() throws InterruptedException { if(ticketNum<=0){ flag = false; return; } Thread.sleep(100); System.out.println(Thread.currentThread().getName() + "买到了第" + ticketNum-- + "票"); }运行结果：
-
-
同步块
synchronized(Obj){ }Obj称之为同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身。或者是class[反射中讲解]
同步监视器的执行过程
- 第一个线程访问，锁定同步监视器，执行其中代码。（第一个人上厕所，把厕所门关上）
- 第二个线程访问，发现同步监视器被锁定，无法访问。（第二个人去上厕所，发现有人在厕所里面，进不去，就走了）
- 第一个线程访问完毕，解锁同步监视器。（第一个人上完厕所，打开门）
- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问。（第二个人又来上厕所，发现没人，便进去了且关上厕所门）
注意：synchronized方法默认锁的是当前对象（加了修饰符的类 即this），而synchronized(Obj){}同步块是可以指定对象锁定的（锁的对象便是变化的量，需要增删改的对象）
-
完成银行取款案例，利用同步块确保线程安全性
package com.thread_.syn; public class UnsafeBank { public static void main(String[] args) { Account account = new Account(100, "银行卡"); Drawing drawing1 = new Drawing(account,50,"jack"); Drawing drawing2 = new Drawing(account,100,"mary"); drawing1.start(); drawing2.start(); } } class Account{ int money; String name; public Account(int money, String name) { this.money = money; this.name = name; } } class Drawing extends Thread{ Account account; int drawingMoney; int nowMoney; public Drawing(Account account,int drawingMoney,String name){ super(name); this.account = account; this.drawingMoney = drawingMoney; } //取钱 @Override public void run() { synchronized (account){ if(account.money-drawingMoney<0){ System.out.println(Thread.currentThread().getName()+"取钱，余额不足"); return; } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //卡内余额 account.money = account.money - drawingMoney; nowMoney = nowMoney + drawingMoney; System.out.println(account.name + "余额为："+ account.money); System.out.println(this.getName() + "手里的余额为" + nowMoney); } } }
-
死锁
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一同步块同时拥有“两个以上对象的锁时”，就可能会发生死锁的问题
死锁：多个线程互相抱着对方需要的资源，然后形成僵持
-
产生死锁的四个必要条件：
- 互斥条件：一个资源每次只能被一个进程使用。
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
- 不剥夺条件：进程已获得的资源，在未使用之前，不能强行剥夺
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
上面列出了死锁的四个必要条件，我们只需要破坏其中的任意一个或多个条件即可避免死锁发生。例如：银行家算法避免死锁
-
Lock(锁)
- 从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
- ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁
利用ReentrantLock解决买票的并发问题
package com.thread_.lock; import java.util.concurrent.locks.ReentrantLock; public class TestLock { public static void main(String[] args) { TestLock2 testLock2 = new TestLock2(); new Thread(testLock2).start(); new Thread(testLock2).start(); new Thread(testLock2).start(); } } class TestLock2 implements Runnable{ int ticketNum = 10; //定义Lock锁 ReentrantLock lock = new ReentrantLock(); @Override public void run() { try { //加锁 lock.lock(); while (true){ if (ticketNum > 0 ){ System.out.println(ticketNum--); }else { break; } } }finally { //解锁 lock.unlock(); } } }
-
synchronized与Lock的对比
- Lock是显式锁（手动开启和关闭锁，一定要关闭锁！）；synchronized是隐式锁，出了作用域便会自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（Lock锁提供更多的子类）
- 优先使用顺序
- Lock>同步代码块>同步方法
线程协作
-
生产者和消费者模式（问题）
-
分析
这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件
- 对于生产者，没有生产产品之前，要通知消费者等待。而生产了产品之后，又需要马上通知消费者消费
- 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
- 在生产者消费者问题中，仅有synchronized是不够的！
- synchronized可阻止并发更新同一个共享资源，实现了同步
- synchronized不能用来实现不同线程之间的消息传递（线程通信）
Java提供了几个方法来解决线程之间的通信问题
- wait()：表示线程会一直等待，直到其他线程通知，与sleep不同，该方法会释放锁
- wait(long timeout)：指定等待的毫秒数
- notify()：唤醒一个处于等待状态的线程
- notifyAll()：唤醒同一个对象上所以调度wait()方法的线程，优先级别高的线程优先调度
注意！上述方法均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常
-
利用管程法解决生产者消费者问题
-
生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；
-
消费者：负责处理数据的模块（可能是方法，对象，线程，进程）；
-
缓冲区：消费者不能直接使用生产者的数据，他们之间有一个缓冲区；生产者将生产好的数据放入缓冲区，消费者从缓冲区中拿出数据
package com.thread_.lock; //管程法解决生产者消费者问题 //需要的对象：生产者，消费者，缓冲区，产品 public class TestPC { public static void main(String[] args) { SynContainer synContainer = new SynContainer(); Producer producer = new Producer(synContainer); Customer customer = new Customer(synContainer); new Thread(producer).start(); new Thread(customer).start(); } } //产品 class Chicken { int id; public Chicken(int id) { this.id = id; } } //生产者 class Producer extends Thread{ SynContainer synContainer; public Producer(SynContainer synContainer){ this.synContainer = synContainer; } @Override public void run() { for (int i = 1; i < 50; i++) { try { synContainer.push(new Chicken(i)); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("生产了第"+i+"只鸡"); } } } //消费者 class Customer extends Thread{ SynContainer synContainer; public Customer(SynContainer synContainer){ this.synContainer = synContainer; } @Override public void run() { for (int i = 1; i < 50; i++) { try { System.out.println("消费了第" + synContainer.pop().id+"只鸡"); } catch (InterruptedException e) { e.printStackTrace(); } } } } //缓冲区 class SynContainer{ //规定容器的容量 Chicken[] chickens = new Chicken[10]; private int count; //生产者把产品放入到缓冲区 public synchronized void push(Chicken chicken) throws InterruptedException { //如果容器满了，等待消费者消费，停止生产 if (count == chickens.length){ //线程阻塞，等待消费者通知 this.wait(); System.out.println("缓冲区满了，消费者消费"); } //如果没有满，就需要丢入产品 chickens[count] = chicken; count++; //有产品了，通知消费者消费 this.notify(); } //消费者消费产品 public synchronized Chicken pop() throws InterruptedException { //判断能否消费 if (count == 0){ //没产品了，等待生产者生产 this.wait(); } //如果可以消费 count--; Chicken chicken = chickens[count]; //通知生产者拿走了鸡 this.notify(); return chicken; } } -
-
利用信号灯法解决生产者消费者问题
package com.thread_.lock; import javafx.stage.Stage; //信号灯法：利用标志位解决 public class TestPC2 { public static void main(String[] args) { StageShow stageShow = new StageShow(); Player player = new Player(stageShow); Watcher watcher = new Watcher(stageShow); new Thread(player).start(); new Thread(watcher).start(); } } //生产者 ->演员 class Player extends Thread { StageShow stage; public Player(StageShow stage) { this.stage = stage; } @Override public void run() { for (int i = 0; i < 10; i++) { if(i%2 ==0){ try { this.stage.Play("海贼王"); } catch (InterruptedException e) { e.printStackTrace(); } }else { try { this.stage.Play("火影忍者"); } catch (InterruptedException e) { e.printStackTrace(); } } } } } //消费者 ->观众 class Watcher extends Thread { StageShow stage; public Watcher(StageShow stage) { this.stage = stage; } @Override public void run() { for (int i = 0; i < 10; i++) { stage.Watch(); } } } //缓冲区 ->舞台 class StageShow { String voice; boolean flag = true; //演员表演，观众等待 public synchronized void Play(String voice) throws InterruptedException { if (flag != true) { this.wait(); } System.out.println("演员表演了：" + voice); this.voice = voice; this.flag = !this.flag; //表演完成，唤醒观众 this.notifyAll(); } public synchronized void Watch() { if (flag) { try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("观众观看了：" + voice); this.flag = !this.flag; //观看完成，唤醒演员 this.notifyAll(); } }
线程池
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
-
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完毕后放回池中，可以避免频繁的创建销毁、实现重复利用。类似于生活中的交通工具
-
好处：
- 提高了响应速度（减少创建新线程的时间）
- 降低资源的消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
- corePoolSize：管理核心池（线程池）的大小
- maximumPoolSize：管理最大线程数
- keepAliveTime：管理线程没有任务时最多保持多少时间后悔终止
-
JDK5.0起提供了线程池相关API：ExecutorService和Executors
-
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
- Future submit (Callable task)：执行任务/命令，有返回值，一般用来执行Callable
- void shundown()：关闭连接池
-
Executors：工具类、线程池工厂类，用于创建并返回不同类型的线程池
-
线程池创建的演示
package com.thread_.lock; import java.util.concurrent.Executors; import java.util.concurrent.ExecutorService; public class TestPool { public static void main(String[] args) { //1.创建服务，创建指定大小的线程池 ExecutorService service = Executors.newFixedThreadPool(10); //2.执行 service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); //3.关闭线程池 service.shutdownNow(); } } class MyThread implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()); } }
总结：ExecutorService通过Executors方法创建线程池，然后执行execute方法或submit 方法来执行服务。