1、 认识线程(Thread)
1.1 概念
一个线程就是一个 "执行流". 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 "同时" 执行 着多份代码.
举个生活中的例子:
想象一下你去一家咖啡店点咖啡的情景。在这个例子中,我们可以将这家咖啡店看作是一个程序,而店内的工作人员则可以视为线程。
假设这家咖啡店提供两种服务:一种是现场制作咖啡,另一种是准备外卖订单。为了提高效率,咖啡店安排了两个工作人员分别负责这两项工作。
-
现场制作咖啡:一位工作人员专门负责为现场顾客制作咖啡。当顾客下单后,这位工作人员就开始准备咖啡,并且在完成后交给顾客。这就好比一个线程,它专注于执行一项任务,即现场咖啡的制作。
-
准备外卖订单:另一位工作人员则专门负责处理外卖订单。当收到外卖订单时,他会开始准备,并打包好放在取货区等待配送员取走。这也代表了一个独立的线程,它负责执行另一项任务,即外卖订单的准备。
这里有几个关键点:
- 共享资源:咖啡豆、牛奶等原材料是所有工作人员共用的,就像线程共享进程中的资源一样。
- 并发执行:两个工作人员可以同时进行各自的工作,这类似于多线程程序中的并发执行。
- 协调:如果原料不足,工作人员之间可能需要协调以确保工作能够顺利进行。在程序中,线程之间也需要通过锁或其他同步机制来协调对共享资源的访问。
进程和线程的区别:
- 资源管理:进程有独立的资源;线程共享所属进程的资源。
- 通信方式:进程间通信需要通过IPC机制;线程间通信直接访问共享内存。
- 开销:进程创建和切换开销大;线程创建和切换开销小。
- 并发能力:线程支持更好的并发执行。
- 安全性:进程提供更好的隔离和安全性。
- 定义:进程是系统分配资源的最小单位,线程是系统调度的最小单位。
2、创建线程
2.1 继承 Thread 类
(1) 继承 Thread 来创建一个线程类.
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线MyThread " + i);
}
}
}
(2) 创建 MyThread 类的实例
MyThread t = new MyThread();
(3) 调用 start 方法启动线程
t.start(); // 线程开始运行
完整代码:
package javaeeDay01.src.thread;
public class Test {
//main方法是由一条默认的主线程负责执行的
public static void main(String[] args) {
// 创建Thread线程类的对象 代表一个线程
Thread t = new MyThread();
// 启动线程
t.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程main " + i);
}
}
}
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线MyThread " + i);
}
}
}
方式一优缺点:
优点:编码简单
缺点:线程类已经继承Thread,无法继承其他类,不利于功能的扩展
多线程注意事项:
1、启动线程调用start方法,不是调用run方法。
2、不要将主线程放在启动子线程之前。
2.2 实现 Runnable 接口
(1) 实现 Runnable 接口
class myRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程 " + i);
}
}
}
(2) 创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数.
//创建任务对象
Runnable target = new myRunnable();
//把任务对象交给一个线程对象处理
Thread t = new Thread(target);
(3) 调用 start 方法
t.start(); // 线程开始运行
完整代码:
package javaeeDay01.src.thread;
public class Test {
public static void main(String[] args) {
//创建任务对象
Runnable target = new myRunnable();
//把任务对象交给一个线程对象处理
Thread t = new Thread(target);
t.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程 " + i);
}
}
}
class myRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程 " + i);
}
}
}
方式二的优缺点:
优点:任务类只是实现接口,可以继承其他类,实现其他接口,扩展性强。
缺点:可省略。
对比上面两种方法:
通常情况下,实现 Runnable
接口更常见,因为它提供了更大的灵活性,并且在大多数情况下都能满足需求。然而,如果只需要简单的线程功能并且不想引入额外的类,那么继承 Thread
类可能更为方便。
其他方式创建多线程
匿名内部类创建 Runnable 子类对象
package javaeeDay01.src.thread;
public class Test {
public static void main(String[] args) {
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程 " + i);
}
}
};
new Thread(target).start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程 " + i);
}
}
}
简化形式1:
package javaeeDay01.src.thread;
public class Test {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程 " + i);
}
}
}).start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程 " + i);
}
}
}
简化形式2:
package javaeeDay01.src.thread;
public class Test {
public static void main(String[] args) {
new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("子线程 " + i);
}
}).start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程 " + i);
}
}
}
2.3 实现 Callable 接口
前两种线程创建方式都存在的一个问题
假如线程执行完毕后有一些数据需要返回,他们重写的run方法均不能直接返回结果。
怎么解决这个问题?
JDK5.O提供了Callable接口和FutureTask类来实现(多线程的第三种创建方式)。
这种方式最大的优点:可以返回线程执行完毕后的结果。
(1)创建任务对象
定义一个类实现Callable接口,重写call方法,封装要做的事情,和要返回的数据
把Callable类型的对象封装成FutureTask(线程任务对象)。
(2)线程任务对象交给Thread对象。
(3)调用Thread对象的start方法启动线程。
(4)线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果。
FutureTask的API
FutureTask提供的构造器 | 说明 |
public FutureTask<>(Callable call) | 把Callable对象封装成FutureTask对象。 |
FutureTask提供的方法 | 说明 |
public V get() throws Exception | 获取线程执行call方法返回的结果。 |
线程创建方式三的优缺点
优点:线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强;可以在线程执行完毕 后去获取线程执行的结果。
缺点:编码复杂一点。
package javaeeDay01.Test;
import javax.swing.*;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test04 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 创建一个Callable对象
Callable<String> call = new MyCallable(100);
// 把Callable对象封装到FutureTask对象中
FutureTask<String> f1 = new FutureTask<>(call);
// 未来任务对象的
// 1、是一个任务对象 实现Runnable接口
// 2、可以在线程执行完毕之后,用未来任务对象调用get方法获取线程执行完毕后的结果
// 创建一个线程对象
new Thread(f1).start();
//代码执行到这儿 上面线程未执行完 代码到这里会暂停 等待上面的线程执行完再获取结果
String str =f1.get();
System.out.println(str);
}
}
//实现callable接口
class MyCallable implements Callable<String> {
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 "线程求出了 1-" + n + "的总和:" + sum;
}
}
注意:调用get()时 会抛出异常 或者 返回正确的字符串
3、Thread提供线程操作的相关方法和构造函数
Thread提供的常用方法 | 说明 |
public void run() | 线程的任务方法 |
public void start() | 启动线程 |
public String getName() | 获取当前线程的名称,线程名称默认是Thread-索引 |
public void setName(String name) | 为线程设置名称 |
public static Thread currentThread() | 获取当前执行的线程对象 |
public static void sleep(long time) | 让当前执行的线程休眠多少毫秒后,再继续执行 |
public final void join()... | 让调用当前这个方法的线程先执行完! |
Thread提供的常见构造器 | 说明 |
public Thread(String name) | 可以为当前线程指定名称 |
public Thread(Runnable target) | 封装Runnable对象成为线程对象 |
public Thread(Runnable target, String name) | 封装Runnable对象成为线程对象,并指定线程名称 |
getName()方法:
package javaeeDay01.Test;
public class Test05 {
public static void main(String[] args) {
Thread t1 = new MyThread();
t1.start();
System.out.println(t1.getName());
// for (int i = 1; i <= 5; i++) {
// System.out.println("Main输出:" + i);
// }
}
}
class MyThread extends Thread {
// public MyThread(String name) {
// super(name);
// }
@Override
public void run() {
for (int i = 1; i <= 3; i++) {
System.out.println("子线程输出:" + i);
}
}
}
setName方法():
package javaeeDay01.Test;
public class Test05 {
public static void main(String[] args) {
Thread t1 = new MyThread();
t1.setName("子线程1");
t1.start();
System.out.println(t1.getName());
// for (int i = 1; i <= 5; i++) {
// System.out.println("Main输出:" + i);
// }
}
}
class MyThread extends Thread {
// public MyThread(String name) {
// super(name);
// }
@Override
public void run() {
for (int i = 1; i <= 3; i++) {
System.out.println("子线程输出:" + i);
}
}
}
注意:
currentThread()方法
package javaeeDay01.Test;
public class Test05 {
public static void main(String[] args) {
Thread t1 = new MyThread();
t1.setName("子线程1");
t1.start();
System.out.println(t1.getName());
//获取当前执行的线程对象
Thread m = Thread.currentThread();
//获取当前执行的线程对象的名字
System.out.println(m.getName());
for (int i = 1; i <= 5; i++) {
System.out.println("Main输出:" + i);
}
}
}
class MyThread extends Thread {
// public MyThread(String name) {
// super(name);
// }
@Override
public void run() {
for (int i = 1; i <= 3; i++) {
System.out.println("子线程输出:" + i);
}
}
}
子线程1、子线程2、主线程的执行情况:
package javaeeDay01.Test;
public class Test05 {
public static void main(String[] args) {
Thread t1 = new MyThread();
t1.setName("子线程1");
t1.start();
System.out.println(t1.getName());
Thread t2 = new MyThread();
t2.setName("子线程2");
t2.start();
System.out.println(t2.getName());
//获取当前执行的线程对象
Thread m = Thread.currentThread();
//获取当前执行的线程对象的名字
m.setName("主线程");
System.out.println(m.getName());
for (int i = 1; i <= 5; i++) {
System.out.println("Main输出:" + i);
}
}
}
class MyThread extends Thread {
// public MyThread(String name) {
// super(name);
// }
@Override
public void run() {
for (int i = 1; i <= 3; i++) {
System.out.println("子线程输出:" + i);
}
}
}
使用构造器对线程名称进行命名:
package javaeeDay01.Test;
public class Test05 {
public static void main(String[] args) {
Thread t1 = new MyThread("子线程1");
t1.start();
System.out.println(t1.getName());
Thread t2 = new MyThread("子线程2");
t2.start();
System.out.println(t2.getName());
//获取当前执行的线程对象
Thread m = Thread.currentThread();
//获取当前执行的线程对象的名字
m.setName("主线程");
System.out.println(m.getName());
for (int i = 1; i <= 5; i++) {
System.out.println(m.getName() + "输出:" + i);
}
}
}
class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
Thread t = Thread.currentThread();
for (int i = 1; i <= 3; i++) {
System.out.println(t.getName() + "输出:" + i);
}
}
}
sleep()方法:
package javaeeDay01.Test;
public class Test06 {
public static void main(String[] args) throws InterruptedException {
for (int i = 1; i <= 5; i++) {
System.out.println(i);
if (i == 3) {
System.out.println("暂停五秒");
//让当前执行的线程暂停5秒
Thread.sleep(5000);
}
}
}
}
join()方法:
package javaeeDay01.Test;
public class Test05 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new MyThread("子线程1");
t1.start();
t1.join();
Thread t2 = new MyThread("子线程2");
t2.start();
t1.join();
//获取当前执行的线程对象
Thread m = Thread.currentThread();
//获取当前执行的线程对象的名字
m.setName("主线程");
for (int i = 1; i <= 5; i++) {
System.out.println(m.getName() + "输出:" + i);
}
}
}
class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
Thread t = Thread.currentThread();
for (int i = 1; i <= 3; i++) {
System.out.println(t.getName() + "输出:" + i);
}
}
}
4、 线程同步
线程同步:解决线程安全问题的方案。
线程同步的思想:让多个线程实现先后依次访问共享资源,这样就解决了安全问题。
线程同步的常见方案:
加锁:每次只允许一个线程加锁,加锁后才能进入访问,访问完毕后自动解锁,然后其他线程才能再加锁进来。
方式一:同步代码块
作用:把访问共享资源的核心代码给上锁,以此保证线程安全。
synchronized(同步锁){
访问共享资源的核心代码
}
原理:每次只允许一个线程加锁后进入,执行完毕后自动解锁,其他线程才可以进来执行。
同步锁的注意事项
对于当前同时执行的线程来说,同步锁必须是同一把(同一个对象),否则会出bug。
运行下列代码:
package Test2;
public class ThreadTest {
public static void main(String[] args) {
Account account1 = new Account("ICBC-111/", 100_000);
new DrawThread(account1, "甲").start();
new DrawThread(account1, "乙").start();
}
}
package Test2;
public class DrawThread extends Thread {
private Account account;
public DrawThread(Account account, String name) {
super(name);
this.account = account;
}
@Override
public void run() {
account.drawMoney(100_000);
}
}
package Test2;
public class Account {
private String cardId;
private double money;
public Account() {
}
public Account(String cardId, double money) {
this.cardId = cardId;
this.money = money;
}
public static void test() {
synchronized (Account.class) {
}
}
public void drawMoney(double money) {
String name = Thread.currentThread().getName();
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;
}
}
运行结果显然不符合逻辑。
加锁:
package Test2;
public class Account {
private String cardId;
private double money;
public Account() {
}
public Account(String cardId, double money) {
this.cardId = cardId;
this.money = money;
}
public static void test() {
synchronized (Account.class) {
}
}
public void drawMoney(double money) {
String name = Thread.currentThread().getName();
synchronized ("锁") {
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;
}
}
添加锁会产生弊端:
package Test2;
public class ThreadTest {
public static void main(String[] args) {
Account account1 = new Account("ICBC-111/", 100_000);
new DrawThread(account1, "甲").start();
new DrawThread(account1, "乙").start();
Account account2 = new Account("ICBC-222/", 100_000);
new DrawThread(account2, "丙").start();
new DrawThread(account2, "丁").start();
}
}
结果显然不符合逻辑
因为:synchronized ("锁") {} 中的”锁“ 在常量池中只有一份,此锁也会使得 丙 ,丁 无法正常串行。
解决方法:
package Test2;
public class Account {
private String cardId;
private double money;
public Account() {
}
public Account(String cardId, double money) {
this.cardId = cardId;
this.money = money;
}
public static void test() {
synchronized (Account.class) {
}
}
public void drawMoney(double money) {
String name = Thread.currentThread().getName();
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 + "取钱失败 余额不足");
}
}
}
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;
}
}
甲乙线程执行 此时this 代表account1
丙丁线程执行 此时this 代表account2
静态方法添加锁:
对于静态方法建议使用字节码(类名.class)对象作为锁对象。
public static void test() {
synchronized (Account.class) {
}
}
方式二:同步方法
作用:把访问共享资源的核心方法给上锁,以此保证线程安全。
修饰符synchronized返回值类型方法名称(形参列表){
操作共享资源的代码
}
public synchronized void drawMoney(double money) {
String name = Thread.currentThread().getName();
if (this.money >= money) {
System.out.println(name + "取钱" + money + "元");
this.money -= money;
System.out.println(name + "取钱后余额" + this.money + "元");
} else {
System.out.println(name + "取钱失败 余额不足");
}
}
同步代码块好还是同步方法好一点?
范围上:同步代码块锁的范围更小,性能更好,同步方法锁的范围更大,可读性更好。
方式三:Lock锁
lock锁是JDK5开始提供的一个新的锁定操作,通过它可以创建出锁对象进行加锁和解锁,更灵活、更方便、更强大。
lock是接口,不能直接实例化,可以采用它的实现类ReentrantLock来构建Lock锁对象。
构造器 | 说明 |
public ReentrantLock() | 获得Lock锁的实现类对象 |
方法名称 | 说明 |
void lock() | 获得锁 |
void unlock() | 释放锁 |
package Test2;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Account {
private String cardId;
private double money;
private final Lock lock = new ReentrantLock();
public Account() {
}
public Account(String cardId, double money) {
this.cardId = cardId;
this.money = money;
}
public static void test() {
synchronized (Account.class) {
}
}
public synchronized void drawMoney(double money) {
lock.lock();
String name = Thread.currentThread().getName();
if (this.money >= money) {
System.out.println(name + "取钱" + money + "元");
this.money -= money;
System.out.println(name + "取钱后余额" + this.money + "元");
} else {
System.out.println(name + "取钱失败 余额不足");
}
lock.unlock();
}
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;
}
}
若下图选中部分的代码执行出错 解锁操作可能未执行 会造成锁一直是加锁状态 因此将
lock.unlock() 要放在finally()中。
public synchronized void drawMoney(double money) {
String name = Thread.currentThread().getName();
lock.lock();
try {
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) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
5、线程通信
线程通信:多个线程共同操作共享的资源时,线程间通过某种方式互相告知自己的状态,以相互协调,并避免无效的资源争夺。
线程通信的常见模型(生产者与消费者模型)
生产者线程负责生产数据。
费者线程负责消费生产者生产的数据。
注意:生产者生产完数据应该等待自己,通知消费者消费;消费者消费完数据也应该等待自己,再通知生产者生产。
Object类的等待和唤醒方法:
方法名称 | 说明 |
void wait() | 让当前线程等待并释放所占锁,直到另一个线程调用 notify()方法或notilly()方法 |
void notify() | 唤醒正在等待的单个线程 |
void notifyAll() | 唤醒正在等待的所有线程 |
上述方法应该使用当前同步锁对象进行调用
package Test3;
public class ThreadTest {
public static void main(String[] args) {
Desk desk = new Desk();
//三个厨师线程 厨师1 厨师2 厨师3
new Thread(() -> {
while (true) {
desk.put();
}
}, "大厨1").start();
new Thread(() -> {
while (true) {
desk.put();
}
}, "大厨2").start();
new Thread(() -> {
while (true) {
desk.put();
}
}, "大厨3").start();
//吃货线程 吃货1 吃货2
new Thread(() -> {
while (true) {
desk.get();
}
}, "吃货1").start();
new Thread(() -> {
while (true) {
desk.get();
}
}, "吃货2").start();
}
}
package Test3;
import java.util.ArrayList;
import java.util.List;
public class Desk {
private List<String> list = new ArrayList<>();
// 大厨做包子
public synchronized void put() {
try {
String name = Thread.currentThread().getName();
if (list.size() == 0) {
list.add(name + "肉包");
System.out.println(name + "做了一个肉包");
Thread.sleep(2000);
//唤醒别人 等待自己
this.notifyAll();
this.wait();
} else {
this.notifyAll();
this.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//吃货拿包子
public synchronized void get() {
try {
String name = Thread.currentThread().getName();
if (list.size() == 1) {
System.out.println(name + "吃了:" + list.get(0));
list.clear();
Thread.sleep(1000);
this.notifyAll();
this.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
6、线程池
线程池:线程池就是一个可以复用线程的技术。
若不使用线程池,用户每发起一个请求,后台就需要创建一个新线程来处理,下次新任务来了肯定又要创建新线程处理的,而创建新线程的开销是很大的,并且请求过多时,肯定会产生大量的线程出来,这样会严重影响系统的性能。
JDK5.0起提供了代表线程池的接口:ExecutorService。
如何得到线程池对象?
方式一:使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象。
ThreadPoolExecutor构造器
public ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
参数一:corePoolSize:指定线程池的核心线程的数量。 ==> 正式工:3
参数二:maximumPoolSize:指定线程池的最大线程数量。 ==> 最大员工数:5临时工:2
参数三:keepAliveTime:指定临时线程的存活时间。 ==> 临时工空闲多久被开除
参数四:unit:指定临时线程存活的时间单位(秒、分、时、天)
参数五:workQueue:指定线程池的任务队列。 ==> 客人排队的地方
参数六:threadFactory:指定线程池的线程工厂。 ==> 负责招聘员工的(hr)
参数七:handler:指定线程池的任务拒绝策略(线程都在忙,任务队列也满了的时候,新任务来了该怎么处理)
线程池的注意事项:
1、临时线程什么时候创建?
任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程。
2、什么时候会开始拒绝新任务?
核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始拒绝任务。
方法名称 | 说明 |
void execute(Runnable command) | 执行Runnable任务 |
Future<T> submit(Callable<T> task) | 执行Callable任务,返回未来任务对象,用于获取线程返回的结果 |
void shutdown() | 等全部任务执行完毕后,再关闭线程池 |
List<Runnable> shutdownNow() | 立刻关闭线程池,停止正在执行的任务,并返回队列中未执行的任务 |
1、线程池处理Runnable任务
执行下面代码:
package Test4;
import java.util.concurrent.*;
public class Test {
public static void main(String[] args) {
//创建线程池对象
ExecutorService pool = new ThreadPoolExecutor(3,
5,
8,
TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(4),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
Runnable target = new MyRunnable();
pool.execute(target); //线程池自定创建一个新线程任务,自动处理这个任务,自动执行
pool.execute(target); //线程池自定创建一个新线程任务,自动处理这个任务,自动执行
pool.execute(target); //线程池自定创建一个新线程任务,自动处理这个任务,自动执行
pool.execute(target); //复用前面的核心线程
pool.execute(target);
}
}
package Test4;
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "牛逼 666!");
try {
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
关闭线程池:
pool.shutdown(); //1、等待线程池的任务全部执行完后,关闭线程池
pool.shutdownNow();//2、立即关闭线程池,并中断正在执行的任务
创建临时线程:
package Test4;
import java.util.concurrent.*;
public class Test {
public static void main(String[] args) {
//创建线程池对象
ExecutorService pool = new ThreadPoolExecutor(3,
5,
8,
TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(4),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
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.shutdown(); //等待线程池的任务全部执行完后,关闭线程池
// pool.shutdownNow();//立即关闭线程池,并中断正在执行的任务
}
}
package Test4;
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "牛逼 666!");
try {
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程数 超出maximumPoolSize的个数 程序会抛出异常
package Test4;
import java.util.concurrent.*;
public class Test {
public static void main(String[] args) {
//创建线程池对象
ExecutorService pool = new ThreadPoolExecutor(3,
5,
8,
TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(4),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
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.shutdown(); //等待线程池的任务全部执行完后,关闭线程池
// pool.shutdownNow();//立即关闭线程池,并中断正在执行的任务
}
}
package Test4;
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "牛逼 666!");
try {
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
新任务拒绝策略:
策略 | 详解 |
ThreadPoolExecutor.AbortPolicy | 丢弃任务并抛RejectedExecutionException异常。是是默认的策略 |
ThreadPoolExecutor.DiscardPolicy | 丢弃任务,但是不抛出异常这是不推荐的做法 |
ThreadPoolExecutor.Discard0ldestPolicy | 抛弃队列中等待最久的任务然后把当前任务加入队列中 |
ThreadPoolExecutor.CallerRunsPolicy | 由主线程负责调用任务的run0方法从而绕过线程池直接执行 |
2、线程池处理Callable任务
ExecutorService的常用方法
方法名称 | 说明 |
void execute(μnnable command) | 执行任务/命令,没有返回值,一般用来执行Runnable任务 |
Future<T>submit(Callable<T> task) | 执行任务,返回未来任务对象获取线程结果,一般拿来执行Callable任务 |
void shutdown() | 等任务执行完毕后关闭线程池 |
List<Runnable> shutdownNow() | 立刻关闭,停止正在执行的任务,并返回队列中未执行的任务 |
package Test4;
import java.util.concurrent.*;
public class Test2 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService pool = new ThreadPoolExecutor(3,
5,
8,
TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(4),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
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());
}
}
package Test4;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<String> {
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 Thread.currentThread().getName() +
"线程求出1-" + n + "的和为:" + sum;
}
}
Executors工具类实现线程池
一个线程池的工具类,提供了很多静态方法用于返回不同特点的线程池对象。
方法名称 | 说明 |
public static ExecutorServicnewFixcdThreadPool(int nThreads) | 创建固定线程数量的线程池,如果某个线程因为执行异 常而结束,那么线程池会补充一个新线程替代它。 |
public static ExecutorService newSingleThreadExecutor() | 创建只有一个线程的线程池对象,如果该线程出现异常 而结束,那么线程池会补充一个新线程 |
public static ExecutorService newCachedThreadPool() | 线程数量随着任务增加而增加,如果线程任务执行完毕 且空闲了60s则会被回收掉 |
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) | 创建一个线程池,可以实现在给定的延迟后运行任务, 或者定期执行任务 |
注意:这些方法的底层,都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。
package Test4;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Test3 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//1-2 通过Executors创建一个线性池对象
ExecutorService pool = Executors.newFixedThreadPool(3);
// 核心线程数量配置
// 计算密集任务 核心线程数量=CPU核数+1;
// IO密集任务 核心线程数量=CPU核数*2;
//2、使用线程处理Callable任务
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());
}
}
package Test4;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<String> {
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 Thread.currentThread().getName() +
"线程求出1-" + n + "的和为:" + sum;
}
}
Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险。
7、并发、并行、生命周期
进程:
正在运行的程序(软件)就是一个独立的进程。
线程是属于进程的,一个进程中可以同时运行很多个线程。
进程中的多个线程其实是井发和井行执行的。
并发:
进程中的线程是由CPU负责调度执行的,但CPU能同时处理线程的数量有限,为了保证全部线程都能往前执行,CPU会轮询为系统的每个线程服务,由于CPU切换的速度很快,给我们的感觉这些线程在同时执行,这就是并发。
并行的理解:
在同一个时刻上,同时有多个线程在被CPU调度执行。
线程的生命周期:
也就是线程从生到死的过程中,经历的各种状态及状态转换。
理解线程这些状态有利于提升井发编程的理解能力。
线程的6种状态互相转换:
8、乐观锁和悲观锁
悲观锁:一上来就加锁,没有安全感。每次只能一个线程进入访问完毕后,再解锁。线程安全,性能较差。
package Test5;
public class Test1 {
// Test5.MyRunnable@3b07d329
public static void main(String[] args) {
Runnable target = new MyRunnable1();
for (int i = 1; i <= 100; i++) {
new Thread(target).start();
}
}
}
package Test5;
public class MyRunnable1 implements Runnable {
private int count = 0;
@Override
public void run() {
for (int i = 0; i < 100; i++) {
synchronized (this) {
// System.out.println("count ==>" + (++count));
}
}
}
}
乐观锁:一开始不上锁,认为是没有问题的,等要出现线程安全问题的时候才开始控制。线程安全,性能较好。
package Test5;
public class Test2 {
public static void main(String[] args) {
Runnable tagert = new MyRunnable2();
for (int i = 1; i <= 100; i++) {
new Thread(tagert).start();
}
}
}
package Test5;
import java.util.concurrent.atomic.AtomicInteger;
public class MyRunnable2 implements Runnable {
private AtomicInteger cout = new AtomicInteger();
@Override
public void run() {
for (int i = 0; i < 100; i++) {
synchronized (this) {
System.out.println("count ==>" + cout.incrementAndGet());
}
}
}
}
9、案例:
有100份礼品,小红,小明两人同时发送,当剩下的礼品小于10份的时候则不再送出,利用多线程模拟该过程并将线程的名称打印出来。并最后在控制台分别打印小红,小明各自送出多少分礼物。
package Test6;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Test {
public static void main(String[] args) throws InterruptedException {
List<String> gifts = new ArrayList<>();
String[] giftsName = {"A", "B", "C", "D", "E"};
Random random = new Random();
for (int i = 0; i < 100; i++) {
gifts.add(giftsName[random.nextInt(giftsName.length)] + (i + 1));
}
System.out.println(gifts);
SendThread xm = new SendThread(gifts, "小明");
SendThread xh = new SendThread(gifts, "小红");
xm.start();
xh.start();
xm.join();
xh.join();
System.out.println(xm.getCount());
System.out.println(xh.getCount());
}
}
package Test6;
import java.util.List;
import java.util.Random;
public class SendThread extends Thread {
private List<String> gifts;
public SendThread(List<String> gifts, String name) {
super(name);
this.gifts = gifts;
}
private int count = 0;
@Override
public void run() {
String name = Thread.currentThread().getName();
Random random = new Random();
while (true) {
synchronized (gifts) {
if (gifts.size() < 10) {
break;
}
String gift = gifts.remove(random.nextInt(gifts.size()));
System.out.println(name + "发出: " + gift);
count++;
}
}
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}