1. 多线程的创建
1.1 方式一:继承Thread类
- 定义一个子类MyThread继承线程类java.lang.Thread,重写run()方法
- 创建MyThread类的对象
- 调用线程对象的start()方法启动线程(启动后还是执行run方法的)
/**
目标:多线程的创建方式一:继承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);
}
}
}
方式一优缺点:
- 优点:编码简单
- 缺点:线程类已经继承Thread,无法继承其他类,不利于扩展。
注意:
- 调用start启动线程而不是直接调用run方法
- 将子线程任务放在主线程任务之前
1.2 方式二:
1.2.1 实现Runnable接口
- 定义一个线程任务类MyRunnable实现Runnable接口,重写run()方法
- 创建MyRunnable任务对象
- 把MyRunnable任务对象交给Thread处理
- 调用线程对象的start()方法启动线程
方式二优缺点:
- 优点:线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强
- 缺点:编程多一层对象包装,如果线程有执行结果是不可以直接返回的
1.2.2 实现Runnable接口(匿名内部类形式)
- 可以创建Runnable的匿名内部类对象
- 交给Thread处理
- 调用线程对象的start()启动线程
/**
目标:学会线程的创建方式二(匿名内部类形式)
*/
public class ThreadDemo2Other {
public static void main(String[] args) {
// 3、创建一个任务对象
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程执行输出1:" + i);
}
}
};
// 4、把任务对象交给Thread处理
Thread t = new Thread(target);
// 5、启动线程
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 方式三:利用Callable、FutureTask接口实现
- 得到任务对象
定义类实现Callable接口,重写call方法,封装要做的事情
用FutureTask把Callable对象封装成线程任务对象 - 把线程任务对象交给Thread处理
- 调用Thread的start方法启动线程,执行任务
- 线程执行完毕后,通过FuturreTask的get方法去获取任务执行的结果。
/**
目标:学会线程的创建方式三:实现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任务没有执行完毕,这里的代码会等待,直到线程1跑完才提取结果。
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 = 0; i <= n ; i++) {
sum += i;
}
return "子线程执行的结果是:" + sum;
}
}
方式三优缺点:
- 优点:线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强;可以在线程执行完毕后去获取线程执行的结果。
- 缺点:编码复杂一点
3种方式对比
2. Thread常用API
有很多线程在执行的时候,如何去区分这些线程
- 需要使用Thread的常用方法:getName()、setName()、currentThread()等
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);
}
}
}
- Thread类的线程休眠方法
/**
目标:线程的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);
}
}
}
}
3. 线程安全
- 多个线程同时操作同一个共享资源的时候可能会出现业务安全问题,称为线程安全问题。
4. 线程同步
- 为了解决线程安全问题
- 核心思想:
加锁,把共享资源进行上锁,每次只能一个线程进入访问完毕以后解锁,然后其他线程才能进来。
4.1 方式一:同步代码块
- 作用:把出现线程安全问题的核心代码给上锁
- 原理:每次只能一个线程进入,执行完毕后自动解锁,其他线程才可以进来执行
public void drawmoney(double money) {
// 0、获取是谁来取钱,线程的名字就是人名
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(name + "取钱后剩余:" + this.money);
}else {
// 4、余额不足
System.out.println(name + "来取钱,余额不足!");
}
}
}
锁对象的规范要求:
- 规范上:建议使用共享资源作为锁对象
- 对于实例方法建议使用this作为锁对象
- 对于静态方法建议使用==字节码(类名.class)==对象作为锁对象
4.2 方式二:同步方法
- 作用:把出现线程安全问题的核心方法给上锁
- 原理:每次只能一个线程进入,执行完毕以后自动解锁,其他线程才可以进来执行
同步方法底层原理 - 同步方法其实底层也是有隐式锁对象的,只是锁的范围是整个方法代码
- 如果方法是实例方法:同步方法默认用this作为锁对象。但是代码要高度面向对象!
- 如果方法是静态方法:同步方法默认用类名.class作为的锁对象
4.3 Lock锁
- 为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock,更加灵活、方便。
- Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。
- Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来构建Lock锁对象。
public class Account {
private String cardId;
private double money; // 余额 关键信息
// final修饰后:锁对象是唯一和不可替换的,非常专业
private final Lock lock = new ReentrantLock();
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;
}
/**
小明 小红
*/
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. 线程池【重点】
5.1 线程池概述
- 线程池是一个可以复用线程的技术
5.2 线程池实现的API、参数说明
ThreadPoolExecutor构造器的参数说明
临时线程什么时候创建?
- 新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程
什么时候才会开始拒绝任务?
- 核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝
5.3 线程池处理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(10000000);
} catch (Exception e) {
e.printStackTrace();
}
}
}
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(); // 会等待全部任务执行完毕之后再关闭
}
}
5.4 线程池处理Callable任务
/**
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 = 0; i <= n ; i++) {
sum += i;
}
return Thread.currentThread().getName() + "执行 1-" + n + "的和, 结果是:" + sum;
}
}
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());
}
}
5.5 Executors工具类实现线程池
- Executors:线程池的工具类通过调用方法返回不同类型的线程池对象
注意:Executors的底层其实也是基于线程池的实现类ThreadPoolExecutors创建线程池对象的。
Executors不适合做大型互联网场景的线程池方案,建议使用ThreadPoolExecutor来制定线程池参数,这样可以明确线程池的运行规则,规避资源耗尽的风险
6. 补充知识:定时器
6.1 方式一:Timer
Timer定时器的特点和存在的问题
- Timer是单线程,处理多个任务按照顺序执行,存在延时与设置定时器的时间有出入
- 可能因为其中的某个任务的异常使Timer线程死掉,从而影响后续任务执行
6.2 ScheduledExecutorService定时器(推荐)
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);
}
}
7. 补充知识:线程的并发并行、生命周期
7.1 线程的并发并行
- 并发:CPU分时轮询的执行线程
- 并行:同一个时刻同时在执行
7.2 线程的生命周期