枉玖
V1
2023/05/22阅读：38主题：默认主题
java中的多线程
想要更好更炫酷的阅读体验，欢迎访问我的博客：https://wang-nine.github.io/ 点击下面的超链接快速访问
详细的描述了Java中多线程的创建、使用、同步问题，以及线程池的创建、使用问题，详细的描述了定时器的创建和使用，详细的分析了Java中六种不同的线程转态以及转换。
1.Java中的多线程创建
java中多线程的创建可以分为三种不同的形式：
① 继承Thread类
具体步骤：
1.定义一个类MyThread继承 2.创建MyThread对象 3.调用线程对象的start方法启动线程（启动后会自动执行MyThread中重写的run()方法） 具体的例子如下
public class ThreadDemo1 {
public static void main(String[] args) {
/**
* 3.new一个线程对象
*/
Thread t = new MyThread();
/**
* 4.调用start()方法执行线程
*/
t.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行输出" + i);
}
}
}
/**
* 1.定义一个线程类继承Thread
*/
class MyThread extends Thread {
/**
* 2.重写run方法
*/
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行输出" + i);
}
}
}
注意： 1.为什么不直接调用run方法，而是调用start启动线程 答：直接调用run方法会当成普通方法执行，此时还是相当于单线程执行。 2.为什么主线程任务放在子线程之后？ 答：否则会先执行主线程任务再执行子线程任务。
优缺点： 优点：编程简单 缺点：单继承的局限性，不能继承其他类，不便于扩展。
② 实现Runnable接口
具体步骤：
1.定义一个线程任务类MyRunnable实现Runnable接口，重写run方法 2.创建MyRunnable对象 3.把MyRunnable对象交给Thread处理 具体的例子如下
public class ThreadDemo2 {
public static void main(String[] args) {
/**
* 2.创建MyRunnable对象
*/
Runnable target = new MyRunnable();
/**
* 3.把MyRunnable对象交给Thread处理
*/
Thread t = new Thread(target);
t.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行输出" + i);
}
}
}
/**
* 1.定义一个线程任务类MyRunnable实现Runnable接口，重写run方法
*/
class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行输出" + i);
}
}
}
优缺点： 优点：扩展性强，可以继续继承和实现。 缺点：如果线程有执行结果不能直接返回。
注意：也可通过匿名内部类实现（建议的写法）
/**
* 通过匿名内部类来实现
*/
new Thread(new MyRunnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("匿名内部类子线程的输出" + i);
}
}
}).start();
③ 实现Callable接口，通过FutureTask接口接收返回值（JDK5新增）
1.得到任务对象 第一步：定义一个线程任务类MyCallable实现Callable接口，重写call方法，该方法可以返回结果 第二步：用Future吧Callable对象封装成线程任务对象 2.把线程任务对象交给Thread处理 3.调用Thread的start方法启动任务 4.线程执行完毕后，通过FutureTask的get方法获得结果
具体的例子如下
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class ThreadDemo3 {
public static void main(String[] args) {
/**
* 3.创建任务对象
*/
Callable<String> call1 = new MyCallable(100);
/**
* 4.把Callable任务对象交给FutureTask对象
* FutureTask的作用1：FutureTask实现了Runnable接口，此时就可以交给Thread了
* FutureTask的作用2：可以在线程执行完毕后调用get方法得到线程执行的结果
*/
//Thread t = new Thread(call); 报错，Thread不能接收call对象
FutureTask<String> f1 = new FutureTask<>(call1);
/**
* 5.交给线程处理
*/
Thread t1 = new Thread(f1);
/**
* 6.启动线程
*/
t1.start();
Callable<String> call2 = new MyCallable(200);
FutureTask<String> f2 = new FutureTask<>(call2);
Thread t2 = new Thread(f2);
t2.start();
try {
String rs1 = f1.get(); //直接调用call方法，可能还没有执行完，使用get时若发现线程未执行完会先等线程执行完毕
System.out.println("第一个结果为：" + rs1);
} catch (Exception e) {
e.printStackTrace();
}
try {
String rs2 = f2.get(); //直接调用call方法，可能还没有执行完，使用get时若发现线程未执行完会先等线程执行完毕
System.out.println("第二个结果为：" + rs2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 1.定义一个实现类，实现Callable接口，记得声明结果的数据类型
*/
class MyCallable implements Callable<String> {
/**
* 2.重写call方法
*/
private int n;
public MyCallable(int n) {
this.n = n;
}
@Override
public String call() throws Exception {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
return "子线程执行的结果是" + sum;
}
}
优缺点： 优点：扩展性强，可以继续继承和实现。 可以在线程执行完毕后获取线程执行的结果。 缺点：编程较为复杂。
注意：Callable 与 FutureTask 创建对象时都需要声明类型
2.Java中的多线程常用方法
① 线程名称有关的方法
| 方法名称 | 说明 |
|---|---|
| void setName() | 设置线程名称 |
| String getName(String name) | 获得线程名称 |
| CuurentThread() | 获取当前的线程对象，哪个线程执行，拿到哪个线程对象 |
| 也可在构造器中取名 |
|---|
| public Thread(String name) |
| public Thread(Runnable target) |
| public Thread(Runnable target, String name) |
② 线程休眠有关的方法
| 方法名称 | 说明 |
|---|---|
| sleep(long time) | 单位为ms |
具体的例子如下
public class ThreadDemo1 {
public static void main(String[] args) throws Exception {
Thread t1 = new MyThread("一号线程");
t1.start();
// t1.setName("一号线程");
System.out.println(t1.getName());
Thread t2 = new MyThread("二号线程");
t2.start();
// t2.setName("二号线程");
System.out.println(t2.getName());
//哪个线程执行，拿到哪个线程对象
Thread m = Thread.currentThread();
System.out.println(m.getName());
for (int i = 1; i <= 5; i++) {
System.out.println("Main线程输出" + i);
if(i == 3)
Thread.sleep(3 * 1000); //主线程休眠3000ms
}
}
}
线程的子类，自定义的线程MyThread
public class MyThread extends Thread{
public MyThread(String name) {
//让父类的构造器进行构造
super(name);
}
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println(Thread.currentThread().getName() + "输出" + i);
}
}
}
3.Java中的线程安全问题
问题描述
多个线程同时操作一个共享资源可能会出现业务安全问题，称为线程安全问题
例如小明和小红有一个共同账户，余额为10万元，模拟两人同时取钱10万元 基础的定义代码如下：
① 提供一个账户类，创建一个账户对象代表两个人的共享账户
public class Account {
private String cardId;
private double money; //余额
public Account() {
}
public Account(String cardId, double money) {
this.cardId = cardId;
this.money = money;
}
public void DrawMoney(double money) {
String name = Thread.currentThread().getName(); //获取取钱人的姓名
//1.判断账户中的钱是否足够
if (this.money >= money) {
//2.取钱
System.out.println(name + "来取钱成功，吐出：" + money);
//3.更新余额
this.money -= money;
System.out.println("取钱后剩余：" + this.money);
} else {
//4.余额不足
System.out.println(name + "来取钱，余额不足！");
}
}
/**
* 获取
* @return cardId
*/
public String getCardId() {
return cardId;
}
/**
* 设置
* @param cardId
*/
public void setCardId(String cardId) {
this.cardId = cardId;
}
/**
* 获取
* @return money
*/
public double getMoney() {
return money;
}
/**
* 设置
* @param money
*/
public void setMoney(double money) {
this.money = money;
}
public String toString() {
return "Account{cardId = " + cardId + ", money = " + money + "}";
}
}
② 定义一个线程类，用来处理账户对象
/**
* 取钱的线程类
*/
public class DrawThread extends Thread {
private Account acc; //定义一个账户对象，便于对账户对象进行操作
public DrawThread(Account acc, String name) {
super(name);
this.acc = acc;
}
@Override
public void run() {
acc.DrawMoney(100000);
}
}
③ 创建两个线程对象，传入同一个账户对象
④ 启动两个线程，去同一个账户对象中取钱10万
/**
* 模拟取钱案例
*/
public class ThreadDemo {
public static void main(String[] args) {
/**
* 1.定义线程类，创建一个共享的账户对象
*/
Account acc = new Account("ICBC-999", 100000);
/**
* 2.创建两个线程对象，代表小明和小红同时取钱
*/
new DrawThread(acc, "小明").start();
new DrawThread(acc, "小红").start();
}
}
注意会出现下面的错误样例：
解决方法：线程同步
针对上述错误解决线程安全问题：线程同步（同一个时刻仅有一个线程可以访问共享资源）
① 同步代码块
synchorized(同步锁对象) { 操作共享资源的代码（核心代码） }
注意：同步锁对象对于不同的对象来说唯一即可，同一时间只能被一个人占用，因此可以使用字符串为同步锁对象，字符串在常量池中 注意：上述同步锁对象对于小明小红唯一，但是若有小黑小白另一家庭取钱，此时也会等待，此时会出问题。 锁对象使用任意的唯一对象可以吗？ 答：不可以，会影响其他无关线程的执行。 锁对象的规范要求：使用共享资源作为锁对象 因此：对于实例方法：使用this作为锁对象 对于静态方法：使用字节码（类名.class)作为锁对象
实例代码如下(修改了上述的代码之后，结果正确)
public void DrawMoney(double money) {
String name = Thread.currentThread().getName(); //获取取钱人的姓名
//同步代码块
synchronized (this) {
//1.判断账户中的钱是否足够
if (this.money >= money) {
//2.取钱
System.out.println(name + "来取钱成功，吐出：" + money);
//3.更新余额
this.money -= money;
System.out.println("取钱后剩余：" + this.money);
} else {
//4.余额不足
System.out.println(name + "来取钱，余额不足！");
}
}
}
结果如下： 
② 同步方法
修饰符 synchorized 返回值类型 方法名称(形参列表) { 操作共享资源的代码（核心代码） }
public synchronized void DrawMoney(double money) { //同步方法
String name = Thread.currentThread().getName(); //获取取钱人的姓名
//1.判断账户中的钱是否足够
if (this.money >= money) {
//2.取钱
System.out.println(name + "来取钱成功，吐出：" + money);
//3.更新余额
this.money -= money;
System.out.println("取钱后剩余：" + this.money);
} else {
//4.余额不足
System.out.println(name + "来取钱，余额不足！");
}
}
注意：同步方法底层也有锁对象，为隐式锁对象，锁的范围是整个方法代码 如果方法是实例方法，会用this作为同步锁对象 如果方法是静态方法，会用类名.class作为同步锁对象
注意，上述两种方法中，同步代码块性能较好，范围越小性能越好，相当于一个在厕所外面排队，一个在坑外面排队，但是同步方法更好些更直观，在实际应用中多数使用同步方法
③ 同步锁（JDK5后提供了新的锁对象Lock，更加的灵活方便）
Lock是接口，采用实现类ReentrantLock来构建Lock锁对象
常用api如下
| 方法名称 | 说明 |
|---|---|
| public ReentrantLock() | 获得Lock锁的实现类对象 |
| void lock() | 获得锁 |
| void unlock() | 释放锁 |
//用final修饰，锁对象是唯一且不可替换的
private final Lock lock = new ReentrantLock();
public void DrawMoney(double money) { //同步方法
String name = Thread.currentThread().getName(); //获取取钱人的姓名
//1.判断账户中的钱是否足够
lock.lock(); //上锁
try {
if (this.money >= money) {
//2.取钱
System.out.println(name + "来取钱成功，吐出：" + money);
//3.更新余额
this.money -= money;
System.out.println("取钱后剩余：" + this.money);
} else {
//4.余额不足
System.out.println(name + "来取钱，余额不足！");
}
} finally {
lock.unlock(); //解锁
}
}
注意：一、锁对象声明为final代表锁是唯一且不可替换的 二、unlock放在finally中，防止代码出错而不执行unlock导致程序卡死
4.Java中的多线程通信（综合以上内容的综合样例）
常用的模型：生产者与消费者模型
object中提供的等待唤醒方法如下
| 方法名称 | 说明 |
|---|---|
| void wait() | 当前线程等待并且释放所占锁，直到另外一个线程调用notify()或者notifyaAll |
| void notify() | 唤醒正在等待的单个线程 |
| void notufyAll() | 唤醒正在等待的所有线程 |
上述方法应该使用当前同步锁对象调用 注意：一定是先唤醒别人在等待，相当于自己叫醒别人再晕过去，否则相当于自己先晕过去没法叫人。
实例代码如下 账户类：
public class Account {
private String cardId;
private double money; //余额
public Account(String cardId, double money) {
this.cardId = cardId;
this.money = money;
}
/**
* 小红 小明：取钱
*
* @param money
*/
public synchronized void DrawMoney(double money) {
String name = Thread.currentThread().getName(); //取钱人
try {
if (this.money >= money) {
// 钱够，可以取钱
this.money -= money;
System.out.println(name + "取钱成功，取出" + money + "元！余额是：" + this.money);
// 没钱了
// 钱不够
this.notifyAll(); //唤醒其他所有的线程
this.wait(); //锁对象，让当前线程进入等待
} else {
// 钱不够，不可取
// 唤醒别人存钱，等待自己取钱
this.notifyAll(); //唤醒其他所有的线程
this.wait(); //锁对象，让当前线程进入等待
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 亲爹 干爹 岳父：取钱
*
* @param money
*/
public synchronized void depositMoney(double money) {
String name = Thread.currentThread().getName(); //存钱人
try {
if (this.money == 0) {
//没钱了，存钱
this.money += money;
System.out.println(name + "存钱" + money + "元成功，余额为" + this.money + "元！");
// 存完钱了
this.notifyAll(); //唤醒其他所有的线程
this.wait(); //锁对象，让当前线程进入等待
} else {
// 有钱了，不用存钱
this.notifyAll(); //唤醒其他所有的线程
this.wait(); //锁对象，让当前线程进入等待
}
} catch (Exception e) {
e.printStackTrace();
}
}
public String getCardId() {
return cardId;
}
public void setCardId(String cardId) {
this.cardId = cardId;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
}
取钱线程类：
/**
* 取钱的线程类
*/
public class DrawThread extends Thread {
private Account acc; //定义一个账户对象，便于对账户对象进行操作
public DrawThread(Account acc, String name) {
super(name);
this.acc = acc;
}
@Override
public void run() {
//不断的存取前
while (true) {
acc.DrawMoney(100000);
try {
Thread.sleep(3 * 1000); //每隔三秒取一次钱
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
存钱线程类：
/**
* 取钱的线程类
*/
public class DepositThread extends Thread {
private Account acc; //定义一个账户对象，便于对账户对象进行操作
public DepositThread(Account acc, String name) {
super(name);
this.acc = acc;
}
@Override
public void run() {
//不断的存取前
while (true) {
acc.depositMoney(100000);
try {
Thread.sleep(2 * 1000); //每隔两秒存一次钱
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
主程序：
public class ThreadDemo {
public static void main(String[] args) {
// 三个父亲线程（生产者） 两个孩子线程（消费者） 模拟存取钱通信思想（一存 一取）
// 1.创建账户对象，代表五个人共同操作的账户
Account acc = new Account("ICBC-999", 0); //初始化零元
// 2.创建两个取钱线程 小明 小红
new DrawThread(acc, "小明").start();
new DrawThread(acc, "小红").start();
// 3.创建三个存钱线程 亲爹 干爹 岳父
new DepositThread(acc, "亲爹").start();
new DepositThread(acc, "干爹").start();
new DepositThread(acc, "岳父").start();
}
}
运行结果
5.线程池的创建以及使用
线程池是一个可以复用线程的技术。解决了每次都为新请求创建线程，导致开销较大的问题 JDK5.0起提供了代表线程池的接口：ExecutorService 得到线程池对象的两种办法： 一、使用ExecutorService的实现类ThreadPoolExecutor自己创建一个线程池对象。 二、使用Executors（线程池的工具类）调用方法放回不同特点的线程池对象。
① 线程池的API简介
ThreadPoolExecutor构造器： public ThreadPoolExecutor（int corePoolSize int maximumPoolSize, long keepAliveTIme, TimeUnit unit, BlockingQueue
（重要！！！）注意两点： 临时线程什么时候创建：新任务提交时发现核心线程都在忙，任务队列满，还可以创建临时线程时才会创建。 什么时候开始拒绝任务：核心线程和临时线程都在忙，任务队列都满，新任务过来会拒绝。
ExecutorService的常用方法：
| 方法名称 | 说明 |
|---|---|
| void execute(Runable command) | 执行任务，无返回值，一般用于执行Runnable任务 |
| Future |
执行任务，返回未来任务对象获取线程结果，一般用于执行Runnable任务 |
| void shutdown() | 等待任务执行完毕后关闭线程池 |
| List |
立即关闭，停止正在执行的任务，返回队列中未执行的任务 |
拒绝策略：
| 策略 | 详解 |
|---|---|
| ThreadPoolExecutor.AbortPolicy | 丢弃任务抛出RejectedExecutionException异常 |
| ThreadPoolExecutor.DiscardPolicy | 丢弃任务不抛出异常（不推荐） |
| ThreadPoolExecutor.DiscardOldestPolicy | 抛弃等待最久的任务并把当前任务加入队列 |
| ThreadPoolExecutor.CallerRunsPolicy | 由主线程负责调用的run()方法绕过线程池直接执行，即来新任务主线程亲自服务 |
② 线程池处理Runnable任务
样例代码： Runnable实现代码：
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "输出了：HelloWorld" + i);
}
// 睡眠线程，观察线程的执行情况
try {
System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了，进入休眠状态了~~~");
Thread.sleep(1000000); //让其睡眠时间久一点，便于观察线程池的复用情况
} catch (Exception e) {
e.printStackTrace();
}
}
}
线程池创建代码：
import java.util.concurrent.*;
public class threadPoolDemo1 {
public static void main(String[] args) {
// 1.创建线程池对象
/**
* public ThreadPoolExecutor(int corePoolSize,
* int maximumPoolSize,
* long keepAliveTime,
* TimeUnit unit,
* BlockingQueue<Runnable> workQueue,
* ThreadFactory threadFactory,
* RejectedExecutionHandler handler) {
*/
ExecutorService pool = new ThreadPoolExecutor(3, 5, 6,
TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
// 2.把任务给线程池处理
Runnable target = new MyRunnable();
//核心线程运行
pool.execute(target);
pool.execute(target);
pool.execute(target);
//不创建临时线程
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target); //任务队列满了！！核心线程都忙！！
//创建临时线程
pool.execute(target);
pool.execute(target);
//拒绝策略触发
pool.execute(target);
//关闭线程池（开发一般不使用，线程池作用就是长久存活）
//pool.shutdownNow(); //立即关闭，即使任务未完成也关闭
//pool.shutdown(); //等待任务执行完毕再关闭
}
}
拒绝策略样例： 
线程池运行样例： 
③ 线程池处理Callable任务
样例代码（简单测试一下，Callable实现在上面写过，具体使用方式与Runnable一致）：
import java.util.concurrent.*;
public class threadPoolDemo2 {
public static void main(String[] args) throws Exception {
// 1.创建线程池对象
/**
* public ThreadPoolExecutor(int corePoolSize,
* int maximumPoolSize,
* long keepAliveTime,
* TimeUnit unit,
* BlockingQueue<Runnable> workQueue,
* ThreadFactory threadFactory,
* RejectedExecutionHandler handler) {
*/
ExecutorService pool = new ThreadPoolExecutor(3, 5, 6,
TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
// 2.把任务给线程池处理
Future<String> f1 = pool.submit(new MyCallable(100));
Future<String> f2 = pool.submit(new MyCallable(200));
Future<String> f3 = pool.submit(new MyCallable(300));
Future<String> f4 = pool.submit(new MyCallable(400));
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
}
}
线程池运行样例： 
④ （重要！） Executors工具类实现线程池
Executors获得线程池的常用方法：
| 方法名称 | 说明 |
|---|---|
| public static ExecutorService newCachedThreadPool() | 线程数随着任务增加而增加，若线程任务执行完毕且空闲一段时间会被回收 |
| public static ExecutorService newFixedThreadPool() | 创建固定数量的线程池。若某个线程因为异常而结束，那么线程池会补充一个新线程代替它 |
| public static ExecutorService newSingleThreadExecutor() | 创建只有一个线程对象的线程池对象，如果该线程因为异常而结束，那么线程池会补充一个新线程 |
| public static ScheduledExecutorService newScheduledThreadPool(int PoolSize) | 创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务 |
注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象 注意：大型并发环境使用Executors如果不注意可能会出现系统风险，例如阿里开发手册不建议使用Executors创建线程池对象，而是建 议使用ThreadPoolExecutor自己创建
| 方法名称 | 存在问题 |
|---|---|
| public static ExecutorService newCachedThreadPool() | 允许请求的任务队列长度为Integer.MAX_VALUE，可能出现OOM错误(OutOfMemoryError) |
| public static ExecutorService newFixedThreadPool() | 同上 |
| public static ExecutorService newSingleThreadExecutor() | 创建的线程数量上限为Integer.MAX_VALUE，线程数随着任务1:1增长，可能出现OOM错误(OutOfMemoryError) |
| public static ScheduledExecutorService newScheduledThreadPool(int PoolSize) | 同上 |
6.补充知识
① 定时器
定时器是一种控制任务延时调用，或者周期调用的技术 作用：闹钟，定时邮件发送
定时器的两种实现方式如下
Timer
| 构造器 | 说明 |
|---|---|
| public Timer() | 创建Timer定时器对象 |
| 方法 | 说明 |
|---|---|
| public void schedule(TimerTask task, long delay, long period） | 开启一个定时器，按照计划处理TimerTask任务，delay是延时，period是周期 |
注意：TimerTask是Runnable的实现类
存在的问题： Timer是单线程，处理多个任务有序执行，存在演示与设置定时器的时间有出入 可能因为某个任务的异常使得Timer线程死掉，从而影响后续任务的执行
样例代码如下：
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class TimerDemo1 {
public static void main(String[] args) {
// 1.创建Timer定时器
Timer timer = new Timer(); //本身就是一个单线程
// 2.调用方法，给定定时任务
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行任务A~~~" + new Date());
try {
Thread.sleep(5000); //休眠5s
} catch (Exception e) {
e.printStackTrace();
}
}
}, 0, 2000); //三秒后执行，每隔两秒执行一次
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行任务B~~~" + new Date());
}
}, 0, 2000);
// 注意，本来A应该7s一次（2s间隔 + 5s睡眠），B应该2s一次
// 实际情况与上述不符合，只存在一个线程，
// B任务受到了A任务的影响
// 其次，如果中间某个线程异常，其余线程都死亡
}
}
运行样例如下: 
ScheduledExecutorService
ScheduledExecutorService弥补了Timer的缺陷
| Executors的方法 | 说明 |
|---|---|
| public static ScheduledExecutorService newScheduledThreadPool(int PoolSize | 得到线程池对象 |
| ScheduledExecutorService的方法 | 说明 |
|---|---|
| public Scheduled<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) | 周期调度方法 |
优点：基于线程池，某个任务的执行情况不会影响其他任务的执行
样例代码如下：
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class TimerDemo2 {
public static void main(String[] args) {
// 1.创建ScheduledExecutorService线程池对象
ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);
// 2.开启定时任务
pool.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行任务A~~~");
//把该线程堵塞
try {
Thread.sleep(100000);
} catch (Exception e) {
e.printStackTrace();
}
}
}, 0, 2, TimeUnit.SECONDS);
pool.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行任务B~~~");
System.out.println(10 / 0); //使该线程异常
}
}, 0, 3, TimeUnit.SECONDS);
pool.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行任务C~~~");
}
}, 0, 3, TimeUnit.SECONDS);
}
}
运行样例如下： 
异常不会影响 也不受其他任务的影响
② 并发与并行
并发与并行： 正在运行的程序（软件）就是一个独立的进程，线程是属于进程的，多个线程其实是并发与并行同时进行的。
并发的理解： CPU同时处理线程的数量有限。 CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。
并行的理解： 在同一个时刻上，同时有多个线程在被CPU处理并执行。
③ （重点！！！）线程的生命周期
线程的状态: 也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。理解线程的状态有利于提升并发编程的理解能力。
Java线程的状态： Java总共定义了6种状态 6种状态都定义在Thread类的内部枚举类中。
线程6种状态的转换如下图
注意以下几点： sleep()是睡眠，过程中不会释放锁对象，醒来后直接进入可运行状态 wait()是等待，过程中会释放锁对象，但是时间到了或者被notity时会重新获得锁对象，进入可运行状态
总结：
| 线程状态 | 描述 |
|---|---|
| NEW（新建） | 线程刚被创建，但是并未启动。 |
| Runnable（可运行） | 线程已经调用了start()等待CPU调度 |
| Blocked（锁阻塞） | 线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态 |
| Waiting（无限等待） | 一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒 |
| Time Waiting（计时等待） | 同waiting状态，有几个方法有超时参数，调用他们将进入Timed waiting状态。带有超时参数的常用方法有Thread.sleep和Object.wait |
| Teminated（被终止） | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。 |
作者介绍
枉玖
V1
话不投机半句多