一、多线程常用方法
最后再演示一下join这个方法是什么效果。
join方法作用：让当前调用这个方法的线程先执行完。
二、线程安全问题
2.1 线程安全问题概述
线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题。
场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，小红和小明同时来取钱，并且2人各自都在取钱10万元，可能出现什么问题呢？
取钱案例中的问题，就是线程安全问题的一种体现。
2.2 线程安全问题的代码演示
先定义一个共享的账户类
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){
System.out.println(name + "来取钱" + money + "成功！");
this.money -= money;
System.out.println(name + "来取钱后，余额剩余：" + this.money);
}else {
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 ThreadTest {
public static void main(String[] args) {
// 1、创建一个账户对象，代表两个人的共享账户。
Account acc = new Account("ICBC-110", 100000);
// 2、创建两个线程，分别代表小明 小红，再去同一个账户对象中取钱10万。
new DrawThread(acc, "小明").start(); // 小明
new DrawThread(acc, "小红").start(); // 小红
}
}运行程序，执行效果如下。你会发现两个人都取了10万块钱，余额为-10完了。
2.3 线程同步方案
为了解决前面的线程安全问题，我们可以使用线程同步思想。同步最常见的方案就是加锁，意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。
2.4 同步代码块
它的作用就是把访问共享数据的代码锁起来，以此保证线程安全。
//锁对象：必须是一个唯一的对象（同一个地址）
synchronized(锁对象){
//...访问共享数据的代码...
}使用同步代码块，来解决前面代码里面的线程安全问题。我们只需要修改DrawThread类中的代码即可。
// 小明 小红线程同时过来的
public void drawMoney(double money) {
// 先搞清楚是谁来取钱？
String name = Thread.currentThread().getName();
// 1、判断余额是否足够
// this正好代表共享资源！
synchronized (this) {
if(this.money >= money){
System.out.println(name + "来取钱" + money + "成功！");
this.money -= money;
System.out.println(name + "来取钱后，余额剩余：" + this.money);
}else {
System.out.println(name + "来取钱：余额不足~");
}
}
}锁对象如何选择
1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
2.对于实例方法，建议使用this作为锁对象
3.对于静态方法，建议把类的字节码(类名.class)当做锁对象2.5 同步方法
其实同步方法，就是把整个方法给锁住，一个线程调用这个方法，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。
同步方法也是有锁对象，只不过这个锁对象没有显示的写出来而已。
1.对于实例方法，锁对象其实是this（也就是方法的调用者）
2.对于静态方法，锁对象时类的字节码对象（类名.class）
public synchronized void drawMoney(double money){}下同步代码块和同步方法有什么区别
1.不存在哪个好与不好，只是一个锁住的范围大，一个范围小
2.同步方法是将方法中所有的代码锁住
3.同步代码块是将方法中的部分代码锁住2.6 Lock锁
Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁，和释放锁的目的，使用起来更加灵活。格式如下
1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）
private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
lk.lock(); // 加锁
//...中间是被锁住的代码...
lk.unlock(); // 解锁使用Lock锁改写前面DrawThread中取钱的方法，代码如下
// 创建了一个锁对象
private final Lock lk = new ReentrantLock();
public void drawMoney(double money) {
// 先搞清楚是谁来取钱？
String name = Thread.currentThread().getName();
try {
lk.lock(); // 加锁
// 1、判断余额是否足够
if(this.money >= money){
System.out.println(name + "来取钱" + money + "成功！");
this.money -= money;
System.out.println(name + "来取钱后，余额剩余：" + this.money);
}else {
System.out.println(name + "来取钱：余额不足~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lk.unlock(); // 解锁
}
}
}四、线程池(有认知)
线程池就是一个可以复用线程的技术。
要理解什么是线程复用技术，我们先得看一下不使用线程池会有什么问题，理解了这些问题之后，我们在解释线程复用同学们就好理解了。
假设：用户每次发起一个请求给后台，后台就创建一个新的线程来处理，下次新的任务过来肯定也会创建新的线程，如果用户量非常大，创建的线程也讲越来越多。然而，创建线程是开销很大的，并且请求过多时，会严重影响系统性能。而使用线程池，就可以解决上面的问题。如下图所示，线程池内部会有一个容器，存储几个核心线程，假设有3个核心线程，这3个核心线程可以处理3个任务。
线程池就是一个线程复用技术，它可以提高线程的利用率。
4.2 创建线程池
在JDK5版本中提供了代表线程池的接口ExecutorService，而这个接口下有一个实现类叫ThreadPoolExecutor类，使用ThreadPoolExecutor类就可以用来创建线程池对象。
接下来，用这7个参数的构造器来创建线程池的对象。代码如下
ExecutorService pool = new ThreadPoolExecutor(
3, //核心线程数有3个
5, //最大线程数有5个。 临时线程数=最大线程数-核心线程数=5-3=2
8, //临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
TimeUnit.SECONDS,//时间单位（秒）
new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
Executors.defaultThreadFactory(), //用于创建线程的工厂对象
new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);关于线程池，我们需要注意下面的两个问题
- 临时线程什么时候创建？
新任务提交时，发现核心线程都在忙、任务队列满了、并且还可以创建临时线程，此时会创建临时线程。- 什么时候开始拒绝新的任务？
核心线程和临时线程都在忙、任务队列也满了、新任务过来时才会开始拒绝任务。4.3 线程池执行Runnable任务
创建好线程池之后，接下来我们就可以使用线程池执行任务了。线程池执行的任务可以有两种，一种是Runnable任务；一种是callable任务。下面的execute方法可以用来执行Runnable任务。
先准备一个线程任务类
public class CuoZao implements Runnable{
@Override
public void run() {
// 任务 是搓澡
System.out.println("号码为:"+Thread.currentThread().getName()+" 的师傅,正在给客人搓澡====>盐搓 醋搓");
//模拟搓澡时间
try {
Thread.sleep(7000);//7秒 搓好一个人
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}下面是执行Runnable任务的代码，注意阅读注释，对照着前面的7个参数理解。
package com.itheima.thread;
import java.util.concurrent.*;
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException{
//创建一个线程池 表示澡堂 每一个线程 是一个 搓澡人员
ExecutorService pool = new ThreadPoolExecutor(
3,// 核心搓澡师傅 3个 核心线程数
5,// 最多有五个 3个正式+2个临时 最大线程数
8, // 临时线程存活时间
TimeUnit.SECONDS, // 最多有8秒 摸鱼，超过8秒 开了临时的
new ArrayBlockingQueue<>(5),//任务阻塞队列 可以排队的人数 没来得及搓澡 而排队的客人
Executors.defaultThreadFactory(), //线程的创建工程 死的
//拒绝策略 忙不过来 交给main线程 忙不过老板上
new ThreadPoolExecutor.CallerRunsPolicy()
);
// 执行任务
//创建搓澡任务
CuoZao cz = new CuoZao();
pool.execute(cz);// 核心
pool.execute(cz);// 核心
pool.execute(cz);// 核心
//
pool.execute(cz);// 等待 核心搓完
pool.execute(cz);//等待
pool.execute(cz);//等待
pool.execute(cz);//等待
pool.execute(cz);//等待
// // 核心3 忙碌 -- 任务阻塞队列 5 +1
pool.execute(cz);//等待
pool.execute(cz);//等待
//
// // 5+5 核心+临时 已经在忙了 队伍也满了 老板上 拒绝策略是老板上
pool.execute(cz);//等待
Thread.sleep(17000);
System.out.println("已经空闲了10秒了 会开掉 两个师傅 留下三个师傅");
//
pool.execute(cz);// 核心
pool.execute(cz);// 核心
pool.execute(cz);// 核心
//
//
pool.execute(cz);// 等待 核心搓完
pool.execute(cz);//等待
//可以关闭线程池
pool.shutdown();//都搓完了 在关闭
pool.shutdownNow();//立马 关闭 没搓完 不搓了
}
}执行上面的代码，结果输出如下
