目录
多线程的实现方案二：实现Runnable接口(匿名内部类形式)
多线程的实现方案三：利用Callable、FutureTask接口实现。
什么是线程？
线程(thread)是一个程序内部的一条执行路径。
我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。
程序中如果只有一条执行路径，那么这个程序就是单线程的程序。
多线程是什么？
多线程是指从软硬件上实现多条执行流程的技术。
1.1多线程的创建
方式一：继承Thread类
Thread类
Java是通过java.lang.Thread 类去代表线程的。
按照面向对象的思想，Thread类应该提供了实现多线程的方式。
多线程的实现方案一：继承Thread类
定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
创建MyThread类的对象
调用线程对象的start()方法启动线程（启动后还是执行run方法的）
方式一优缺点：
优点：编码简单
缺点：线程类已经继承Thread，无法继承其他类，不利于扩展。
/**
目标：多线程的创建方式一：继承Thread类实现。
*/
public class ThreadDemo1 {
public static void main(String[] args) {
// 3、new一个新线程对象
Thread t = new MyThread();
// 4、调用start方法启动线程（执行的还是run方法）
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方法会当成普通方法执行，此时相当于还是单线程执行。
只有调用start方法才是启动一个新的线程执行。
2.把主线程任务放在子线程之前了。
这样主线程一直是先跑完的，相当于是一个单线程的效果了。
3.方式一是如何实现多线程的？
继承Thread类
重写run方法
创建线程对象
调用start()方法启动。
1.2方式二：实现Runnable接口
多线程的实现方案二：实现Runnable接口
定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
创建MyRunnable任务对象
把MyRunnable任务对象交给Thread处理。
调用线程对象的start()方法启动线程
Thread的构造器
/**
目标：学会线程的创建方式二，理解它的优缺点。
*/
public class ThreadDemo2 {
public static void main(String[] args) {
// 3、创建一个任务对象
Runnable target = new MyRunnable();
// 4、把任务对象交给Thread处理
Thread t = new Thread(target);
// Thread t = new Thread(target, "1号");
// 5、启动线程
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("主线程执行输出：" + i);
}
}
}
/**
1、定义一个线程任务类 实现Runnable接口
*/
class MyRunnable implements Runnable {
/**
2、重写run方法，定义线程的执行任务的
*/
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程执行输出：" + i);
}
}
}
方式二优缺点：
优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。
总结：
1.第二种方式是如何创建线程的？
定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
创建MyRunnable对象
把MyRunnable任务对象交给Thread线程对象处理。
调用线程对象的start()方法启动线程
多线程的实现方案二：实现Runnable接口(匿名内部类形式)
可以创建Runnable的匿名内部类对象。
交给Thread处理。
调用线程对象的start()启动线程。
/**
目标：学会线程的创建方式二(匿名内部类方式实现，语法形式)
*/
public class ThreadDemo2Other {
public static void main(String[] args) {
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程1执行输出：" + i);
}
}
};
Thread t = new Thread(target);
t.start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程2执行输出：" + i);
}
}
}).start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
System.out.println("子线程3执行输出：" + i);
}
}).start();
for (int i = 0; i < 10; i++) {
System.out.println("主线程执行输出：" + i);
}
}
}
1.3方式三：JDK 5.0新增：实现Callable接口
1.前2种线程创建方式都存在一个问题：
他们重写的run方法均不能直接返回结果。
不适合需要返回线程执行结果的业务场景。
2.怎么解决这个问题呢？
JDK 5.0提供了Callable和FutureTask来实现。
这种方式的优点是：可以得到线程执行的结果。
多线程的实现方案三：利用Callable、FutureTask接口实现。
1.得到任务对象：
a.定义类实现Callable接口，重写call方法，封装要做的事情。
b.用FutureTask把Callable对象封装成线程任务对象。
2.把线程任务对象交给Thread处理。
3.调用Thread的start方法启动线程，执行任务
4.线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。
FutureTask的API
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
目标：学会线程的创建方式三：实现Callable接口，结合FutureTask完成。
*/
public class ThreadDemo3 {
public static void main(String[] args) {
// 3、创建Callable任务对象
Callable<String> call = new MyCallable(100);
// 4、把Callable任务对象 交给 FutureTask 对象
// FutureTask对象的作用1： 是Runnable的对象（实现了Runnable接口），可以交给Thread了
// FutureTask对象的作用2： 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
FutureTask<String> f1 = new FutureTask<>(call);
// 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 {
// 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
String rs1 = f1.get();
System.out.println("第一个结果：" + rs1);
} catch (Exception e) {
e.printStackTrace();
}
try {
// 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
String rs2 = f2.get();
System.out.println("第二个结果：" + rs2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
1、定义一个任务类 实现Callable接口 应该申明线程任务执行完毕后的结果的数据类型
*/
class MyCallable implements Callable<String>{
private int n;
public MyCallable(int n) {
this.n = n;
}
/**
2、重写call方法（任务方法）
*/
@Override
public String call() throws Exception {
int sum = 0;
for (int i = 1; i <= n ; i++) {
sum += i;
}
return "子线程执行的结果是：" + sum;
}
}
方式三优缺点：
优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
可以在线程执行完毕后去获取线程执行的结果。
缺点：编码复杂一点。
总结：
3种方式对比：
2.Thread的常用方法
Thread常用API说明
Thread常用方法：获取线程名称getName()、设置名称setName()、获取当前线程对象currentThread()。
至于Thread类提供的诸如：yield、join、interrupt、不推荐的方法 stop 、守护线程、线程优先级等
线程的控制方法，在开发中很少使用。
当有很多线程在执行的时候，我们怎么去区分这些线程呢？
此时需要使用Thread的常用方法：getName()、setName()、currentThread()等。
Thread获取和设置线程名称
Thread类获得当前线程的对象
注意：
1、此方法是Thread类的静态方法，可以直接使用Thread类调用。
2、这个方法是在哪个线程执行中调用的，就会得到哪个线程对象。
Thread的构造器
Thread类的线程休眠方法
public class MyThread extends Thread{
public MyThread() {
}
public MyThread(String name) {
// 为当前线程对象设置名称，送给父类的有参数构造器初始化名称
super(name);
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println( Thread.currentThread().getName() + "输出：" + i);
}
}
}
/**
目标：线程的API
*/
public class ThreadDemo01 {
// main方法是由主线程负责调度的
public static void main(String[] args) {
Thread t1 = new MyThread("1号");
// t1.setName("1号");
t1.start();
System.out.println(t1.getName());
Thread t2 = new MyThread("2号");
// t2.setName("2号");
t2.start();
System.out.println(t2.getName());
// 哪个线程执行它，它就得到哪个线程对象（当前线程对象）
// 主线程的名称就叫main
Thread m = Thread.currentThread();
System.out.println(m.getName());
m.setName("最牛的线程");
for (int i = 0; i < 5; i++) {
System.out.println( m.getName() + "输出：" + i);
}
}
}
/**
目标：线程的API
*/
public class ThreadDemo02 {
// main方法是由主线程负责调度的
public static void main(String[] args) throws Exception {
for (int i = 1; i <= 5; i++) {
System.out.println("输出：" + i);
if(i == 3){
// 让当前线程进入休眠状态
// 段子：项目经理让我加上这行代码，如果用户愿意交钱，我就注释掉。
Thread.sleep(3000);
}
}
}
}总结：
Thread常用方法、构造器
3.线程安全
线程安全问题是什么、发生的原因
线程安全问题
多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。
取钱模型演示
需求：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元。
如果小明和小红同时来取钱，而且2人都要取钱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) {
// 0、先获取是谁来取钱，线程的名字就是人名
String name = Thread.currentThread().getName();
// 1、判断账户是否够钱
if(this.money >= money){
// 2、取钱
System.out.println(name + "来取钱成功，吐出：" + money);
// 3、更新余额
this.money -= money;
System.out.println(name + "取钱后剩余：" + this.money);
}else {
// 4、余额不足
System.out.println(name +"来取钱，余额不足！");
}
}
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() {
// 小明 小红：取钱
acc.drawMoney(100000);
}
}
/**
需求：模拟取钱案例。
*/
public class ThreadDemo {
public static void main(String[] args) {
// 1、定义线程类，创建一个共享的账户对象
Account acc = new Account("ICBC-111", 100000);
// 2、创建2个线程对象，代表小明和小红同时进来了。
new DrawThread(acc, "小明").start();
new DrawThread(acc, "小红").start();
}
}
总结：
1.线程安全问题出现的原因？
存在多线程并发
同时访问共享资源
存在修改共享资源
2.线程安全问题发生的原因是什么？
多个线程同时访问同一个共享资源且存在修改该资源。
4.线程同步
同步思想概述
线程同步
1.为了解决线程安全问题。
取钱案例出现问题的原因？
多个线程同时执行，发现账户都是够钱的。
2.如何才能保证线程安全呢？
让多个线程实现先后依次访问共享资源，这样就解决了安全问题
线程同步的核心思想
加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。
总结：
线程同步解决安全问题的思想是什么？
加锁：让多个线程实现先后依次访问共享资源，这样就解决了安全问题。
方式一：同步代码块
同步代码块
作用：把出现线程安全问题的核心代码给上锁。
原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。
锁对象要求
理论上：锁对象只要对于当前同时执行的线程来说是同一个对象即可。
锁对象用任意唯一的对象好不好呢?
不好，会影响其他无关线程的执行。
锁对象的规范要求
规范上：建议使用共享资源作为锁对象。
对于实例方法建议使用this作为锁对象。
对于静态方法建议使用字节码（类名.class）对象作为锁对象。
/**
账户类：余额，卡号
*/
public class Account {
private String cardId;
private double money; // 余额 关键信息
public Account() {
}
public Account(String cardId, double money) {
this.cardId = cardId;
this.money = money;
}
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;
}
// // 100个线程人
// public static void run(){
// synchronized (Account.class){
//
// }
// }
/**
小明 小红
*/
public void drawMoney(double money) {
// 1、拿到是谁来取钱
String name = Thread.currentThread().getName();
// 同步代码块
// 小明 小红
// this == acc 共享账户
synchronized (this) {
// 2、判断余额是否足够
if(this.money >= money){
// 钱够了
System.out.println(name+"来取钱，吐出：" + money);
// 更新余额
this.money -= money;
System.out.println(name+"取钱后，余额剩余：" + this.money);
}else{
// 3、余额不足
System.out.println(name+"来取钱，余额不足！");
}
}
}
}
/**
线程类
*/
public class DrawThread extends Thread{
private Account acc;
public DrawThread(Account acc, String name){
super(name);
this.acc = acc;
}
@Override
public void run() {
// 小明 小红 ： acc
acc.drawMoney(100000);
}
}
public class TestSafeDemo {
public static void main(String[] args) {
// 测试线程安全问题
// 1、创建一个共享的账户对象。
Account acc = new Account("ICBC-111" , 100000);
// 2、创建2个线程对象，操作同一个账户对象
new DrawThread(acc, "小明").start();
new DrawThread(acc,"小红").start();
}
}总结：
同步代码块是如何实现线程安全的？
对出现问题的核心代码使用synchronized进行加锁
每次只能一个线程占锁进入访问
同步代码块的同步锁对象有什么要求？
对于实例方法建议使用this作为锁对象。
对于静态方法建议使用字节码（类名.class）对象作为锁对象。
方式二：同步方法
同步方法
作用：把出现线程安全问题的核心方法给上锁。
原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。
同步方法底层原理
同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！
如果方法是静态方法：同步方法默认用类名.class作为的锁对象。
public synchronized void drawMoney(double money) {
// 1、拿到是谁来取钱
String name = Thread.currentThread().getName();
// 2、判断余额是否足够
// 小明 小红
if(this.money >= money){
// 钱够了
System.out.println(name+"来取钱，吐出：" + money);
// 更新余额
this.money -= money;
System.out.println(name+"取钱后，余额剩余：" + this.money);
}else{
// 3、余额不足
System.out.println(name+"来取钱，余额不足！");
}
}同步代码块锁的范围更小，同步方法锁的范围更大。
总结：
1.同步方法是如何保证线程安全的？
对出现问题的核心方法使用synchronized修饰
每次只能一个线程占锁进入访问
2.同步方法的同步锁对象的原理？
对于实例方法默认使用this作为锁对象。
对于静态方法默认使用类名.class对象作为锁对象。
方式三：Lock锁
Lock锁
为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。
Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。
Lock的API
private final Lock lock = new ReentrantLock();
public void drawMoney(double money) {
// 1、拿到是谁来取钱
String name = Thread.currentThread().getName();
// 2、判断余额是否足够
// 小明 小红
lock.lock(); // 上锁
try {
if(this.money >= money){
// 钱够了
System.out.println(name+"来取钱，吐出：" + money);
// 更新余额
this.money -= money;
System.out.println(name+"取钱后，余额剩余：" + this.money);
}else{
// 3、余额不足
System.out.println(name+"来取钱，余额不足！");
}
} finally {
lock.unlock(); // 解锁
}5.线程通信[了解]
什么是线程通信、如何实现？
所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。
线程通信常见形式
通过共享一个数据的方式实现。
根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。
线程通信实际应用场景
生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。
要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。
线程通信案例模拟
模拟客服系统，系统可以不断的接入电话 和 分发给客服。
线程通信的前提：线程通信通常是在多个线程操作同一个共享资源的时候需要进行通信，且要保证线程安全。
Object类的等待和唤醒方法：
注意
上述方法应该使用当前同步锁对象进行调用。
/**
呼叫系统。
*/
public class CallSystem {
// 定义一个变量记录当前呼入进来的电话。
public static int number = 0; // 最多只接听一个。
/* 接入电话
*/
public synchronized static void call() {
try {
number++;
System.out.println("成功接入一个用户，等待分发~~~~");
// 唤醒别人 : 1个
CallSystem.class.notify();
// 让当前线程对象进入等待状态。
CallSystem.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
分发电话
*/
public synchronized static void receive() {
try {
String name = Thread.currentThread().getName();
if(number == 1){
System.out.println(name + "此电话已经分发给客服并接听完毕了~~~~~");
number--;
// 唤醒别人 : 1个
CallSystem.class.notify();
CallSystem.class.wait(); // 让当前线程等待
}else {
// 唤醒别人 : 1个
CallSystem.class.notify();
CallSystem.class.wait(); // 让当前线程等待
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class CallThread extends Thread{
@Override
public void run() {
// 不断的打入电话
while (true){
CallSystem.call();
}
}
}
/**
接电话线程类
*/
public class ReceiveThread extends Thread{
@Override
public void run() {
// 1号 2号
while (true){
CallSystem.receive();
}
}
}
public class TestDemo {
public static void main(String[] args) {
// 1、生产者线程：负责不断接收打进来的电话
CallThread call = new CallThread();
call.start();
// 2、消费者线程：客服，每个客服每次接听一个电话
ReceiveThread r1 = new ReceiveThread();
r1.start();
}
}*6.线程池[重点]
线程池概述
什么是线程池？
线程池就是一个可以复用线程的技术。
不使用线程池的问题？
如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。
线程池实现的API、参数说明
谁代表线程池？
JDK 5.0起提供了代表线程池的接口：ExecutorService
如何得到线程池对象
方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象
ThreadPoolExecutor构造器的参数说明
线程池常见面试题
临时线程什么时候创建啊？
新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
什么时候会开始拒绝任务？
核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。
总结：
谁代表线程池？
ExecutorService接口
ThreadPoolExecutor实现线程池对象的七个参数是什么意思？
使用线程池的实现类ThreadPoolExecutor
线程池处理Runnable任务
ThreadPoolExecutor创建线程池对象示例
ExecutorService的常用方法
新任务拒绝策略
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(); // 会等待全部任务执行完毕之后再关闭（建议使用的）
}
}
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(10000000);
} catch (Exception e) {
e.printStackTrace();
}
}
}
import java.util.concurrent.*;
/**
目标：使用Executors的工具方法直接得到一个线程池对象。
*/
public class ThreadPoolDemo3 {
public static void main(String[] args) throws Exception {
// 1、创建固定线程数据的线程池
ExecutorService pool = Executors.newFixedThreadPool(3);
pool.execute(new MyRunnable());
pool.execute(new MyRunnable());
pool.execute(new MyRunnable());
pool.execute(new MyRunnable()); // 已经没有多余线程了
}
}
总结：
线程池如何处理Runnable任务
使用ExecutorService的方法：
void execute(Runnable target)
线程池处理Callable任务
ExecutorService的常用方法
import java.util.concurrent.Callable;
/**
1、定义一个任务类 实现Callable接口 应该申明线程任务执行完毕后的结果的数据类型
*/
public class MyCallable implements Callable<String>{
private int n;
public MyCallable(int n) {
this.n = n;
}
/**
2、重写call方法（任务方法）
*/
@Override
public String call() throws Exception {
int sum = 0;
for (int i = 1; i <= n ; i++) {
sum += i;
}
return Thread.currentThread().getName()
+ "执行 1-" + n+ "的和，结果是：" + sum;
}
}
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));
Future<String> f5 = pool.submit(new MyCallable(500));
// String rs = f1.get();
// System.out.println(rs);
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
System.out.println(f5.get());
}
}
总结：
线程池如何处理Callable任务，并得到任务执行完后返回的结果。
使用ExecutorService的方法：
Future<T> submit(Callable<T> command)
Executors工具类实现线程池
Executors得到线程池对象的常用方法
Executors：线程池的工具类通过调用方法返回不同类型的线程池对象。
注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。
import java.util.concurrent.*;
/**
目标：使用Executors的工具方法直接得到一个线程池对象。
*/
public class ThreadPoolDemo3 {
public static void main(String[] args) throws Exception {
// 1、创建固定线程数据的线程池
ExecutorService pool = Executors.newFixedThreadPool(3);
pool.execute(new MyRunnable());
pool.execute(new MyRunnable());
pool.execute(new MyRunnable());
pool.execute(new MyRunnable()); // 已经没有多余线程了
}
}
Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险。
总结：
1.Executors工具类底层是基于什么方式实现的线程池对象？
线程池ExecutorService的实现类：ThreadPoolExecutor
2.Executors是否适合做大型互联网场景的线程池方案？
不合适。
建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规则，规避资源耗尽的风险。
7.补充知识：定时器
定时器
定时器是一种控制任务延时调用，或者周期调用的技术。
作用：闹钟、定时邮件发送。
定时器的实现方式
方式一：Timer
方式二： ScheduledExecutorService
Timer定时器
Timer定时器的特点和存在的问题
1.Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。
2.可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
/**
目标：Timer定时器的使用和了解。
*/
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() + "执行AAA~~~" + new Date());
// try {
// Thread.sleep(5000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
}
}, 0, 2000);
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行BB~~~"+ new Date());
System.out.println(10/0);
}
}, 0, 2000);
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行CCC~~~"+ new Date());
}
}, 0, 3000);
}
}
ScheduledExecutorService定时器
ScheduledExecutorService是 jdk1.5中引入了并发包，目的是为了弥补Timer的缺陷, ScheduledExecutorService内部为线程池。
ScheduledExecutorService的优点
基于线程池，某个任务的执行情况不会影响其他定时任务的执行。
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
目标：Timer定时器的使用和了解。
*/
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() + "执行输出：AAA ==》 " + new Date());
try {
Thread.sleep(100000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, 0, 2, TimeUnit.SECONDS);
pool.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行输出：BBB ==》 " + new Date());
System.out.println(10 / 0);
}
}, 0, 2, TimeUnit.SECONDS);
pool.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行输出：CCC ==》 " + new Date());
}
}, 0, 2, TimeUnit.SECONDS);
}
}
8.补充知识：并发、并行
并发与并行
正在运行的程序（软件）就是一个独立的进程， 线程是属于进程的，多个线程其实是并发与并行同时进行的。
并发的理解：
CPU同时处理线程的数量有限。
CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。
并行的理解：
在同一个时刻上，同时有多个线程在被CPU处理并执行。
总结：
并发：CPU分时轮询的执行线程。
并行：同一个时刻同时在执行。
9.补充知识：线程的生命周期
线程的状态
线程的状态：也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。
理解线程的状态有利于提升并发编程的理解能力。
Java线程的状态
Java总共定义了6种状态
6种状态都定义在Thread类的内部枚举类中。
线程的6种状态互相转换
线程的6种状态总结
296
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
