什么是线程?
线程(thread)是一个程序内部的一条执行路径。
我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。
程序中如果只有一条执行路径，那么这个程序就是单线程的程序。
多线程是什么?
多线程是指从软硬件上实现多条执行流程的技术。
多线程的实现方案一:继承Thread类
1.定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
2.创建MyThread类的对象
3.调用线程对象的start()方法启动线程（启动后还是执行run方法的)
package d1_create;
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，无法继承其他类，不利于扩展。
多线程的实现方案二:实现Runnable接口
1.定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
2.创建MyRunnable任务对象
3.把MyRunnable任务对象交给Thread处理。
4.调用线程对象的start()方法启动线程
package d1_create;
import java.lang.annotation.Target;
public class ThreadDemo2 {
public static void main(String[] args) {
//3.创建一个任务对象
Runnable target = new MyRunnable();
//4.把任务对象交给Thread处理
Thread t = new Thread(target);
//5.启动线程
t.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行输出：" + i);
}
}
}
/**
* 1.定义一个线程任务类 实现Runnable接口
*/
class MyRunnable implements Runnable{
/**
* 2.重写run方法，里面是定义线程以后要干啥
*/
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行输出：" + i);
}
}
}
方式二优缺点:
优点:线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
缺点:编程多一层对象包装，如果线程有执行结果是不可以直接返回的。
多线程的实现方案二:实现Runnable接口(匿名内部类形式)
1.可以创建Runnable的匿名内部类对象。
2.交给Thread处理。
3.调用线程对象的start()启动线程。
package d1_create;
public class ThreadDemo2Other {
public static void main(String[] args) {
//创建一个任务对象
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程1执行输出：" + i);
}
}
};
//把任务对象交给Thread处理
Thread t = new Thread(target);
//启动线程
t.start();
// | |
// v
//匿名内部类方式实现（简化）
new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("子线程2执行输出：" + i);
}
}).start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行输出：" + i);
}
}
}
多线程的实现方案三:利用Callable、FutureTask接口实现。
1、得到任务对象
1.定义类实现Callable接口，重写call方法，封装要做的事情。
2.用FutureTask把Callable对象封装成线程任务对象。
2、把线程任务对象交给Thread处理。
3、调用Thread的start方法启动线程，执行任务
4、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。
package d1_create;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.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 {
String rs1 = f1.get();
System.out.println("第一个结果：" + rs1);
} catch (Exception e) {
e.printStackTrace();
}try {
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种方式对比
| 方式 | 优点 | 缺点 |
| 继承Thread类 | 编程比较简单，可以直接使用Thread | 扩展性较差，不能再继承其他的类，不能返回线程执行的结果 |
| 实现Runnable接口 | 扩展性强，实现该接口的同时还可以 | 编程相对复杂，不能返回线程执行的结果 |
| 实现Callable接口 | 扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果 | 编程相对复杂 |
Thread相关api
Thread获取和设置线程名称
getName(） 获取当前线程的名称，默认线程名称是Thread-索引
setName 将此线程的名称更改为指定的名称，通过构造器也可以设置线程名称
Thread类获得当前线程的对象
Thread.currentThread（） 返回对当前正在执行的线程对象的引用
注意
1、此方法是Thread类的静态方法，可以直接使用Thread类调用。
2、这个方法是在哪个线程执行中调用的，就会得到哪个线程对象。
package d2_api;
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);
}
}
}
package d2_api;
public class ThreadDemo1 {
//main方法是由主线程负责调度的
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());
//哪个线程执行它，它就得到哪个线程对象
//主线程的名称就叫main
Thread m = Thread.currentThread();
System.out.println(m.getName());
for (int i = 0; i < 5; i++) {
System.out.println("main线程输出：" + i);
}
}
}
Thread类的线程休眠方法
sleep 让当前线程休眠指定的时间后再继续执行，单位为毫秒。
package d2_api;
public class ThreadDemo2 {
public static void main(String[] args) throws Exception {
for (int i = 0; i < 5; i++) {
System.out.println("输出：" + i);
if (i == 3){
//让当前线程进入休眠状态 //加入这行代码，如果用户愿意交钱，我就注释掉。-手动dog-
Thread.sleep(3000);
}
}
}
}
Thread常用方法、构造器
| 方法名称 | 说明 |
| string getName() | 获取当前线程的名称，默认线程名称是Thread-索引 |
| void setName(String name) | 设置线程名称 |
| public static Thread currentThread(): | 返回对当前正在执行的线程对象的引用 |
| public static void sleep(long time) | 让线程休眠指定的时间，单位为毫秒。 |
| public void run() | 线程任务方法 |
| public void start() | 线程启动方法 |
线程安全问题
多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。
线程同步的核心思想
加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。
同步代码块
作用:把出现线程安全问题的核心代码给上锁。
原理:每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。
锁对象要求
理论上:锁对象只要对于当前同时执行的线程来说是同一个对象即可。
案例——取钱业务
需求:
小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，模拟2人同时去取钱10万。
分析:
①:需要提供一个账户类，创建一个账户对象代表2个人的共享账户。
②:需要定义一个线程类，线程类可以处理账户对象。
③:创建2个线程对象，传入同一个账户对象。
④:启动2个线程，去同一个账户对象中取钱10万。
Account
package d3_Thread_safe;
public class Account {
private String cardId;
private double money;
public void drawMoney(double money){
//a.先获取是谁来取钱，线程的名字就是人名
String name = Thread.currentThread().getName();
//同步代码块
//this == acc 共享账户
synchronized (this) {
//b.判断账户是否够钱
if (this.money == money){
//c.取钱
System.out.println(name + "来取钱成功，吐出：" + money);
//d.更新余额
this.money -= money;
System.out.println(name + "取钱后剩余：" + money);
}else {
//f.余额不足
System.out.println(name + "来取钱，余额不足！");
}
}
}
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;
}
@Override
public String toString() {
return "Account{" +
"cardId='" + cardId + '\'' +
", money=" + money +
'}';
}
}
DrawThread
package d3_Thread_safe;
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);
}
}
ThreadDemo
package d3_Thread_safe;
public class ThreadDemo {
public static void main(String[] args) {
//1.定义线程类，创建一个共享的账户对象
Account acc = new Account("ACBD-001",100000);
//2.创建两个线程对象，代表小明和小红同时进来了
new DrawThread(acc,"小明").start();
new DrawThread(acc,"小红").start();
}
}
锁对象用任意唯一的对象好不好呢?
不好，会影响其他无关线程的执行。
锁对象的规范要求
规范上:建议使用共享资源作为锁对象。
对于实例方法建议使用this作为锁对象。
对于静态方法建议使用字节码(类名.class）对象作为锁对象。
同步方法
作用:把出现线程安全问题的核心方法给上锁。
原理:每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。
格式
修饰符 synchronized 返回值类型 方法名称(形参列表){
操作共享资源的代码
}
同步方法底层原理
同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
如果方法是实例方法:同步方法默认用this作为的锁对象。但是代码要高度面向对象!
如果方法是静态方法:同步方法默认用类名.class作为的锁对象。
Lock锁
为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。
Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。
package d4_thread_synchronized_lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Account {
private String cardId;
private double money;//余额 关键信息
//final修饰后：锁对象是唯一和不可替换的，非常专业
private final Lock lock = new ReentrantLock();
public void drawMoney(double money){
//a.先获取是谁来取钱，线程的名字就是人名
String name = Thread.currentThread().getName();
//b.判断余额是否足够
lock.lock();//上锁
try {
if (this.money >= money){
//c.取钱
System.out.println(name + "来取钱成功，吐出：" + money);
//d.更新余额
this.money -= money;
System.out.println(name + "取钱后剩余：" + money);
}else {
//f.余额不足
System.out.println(name + "来取钱，余额不足！");
}
} finally {
lock.unlock();//解锁
}
}
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;
}
@Override
public String toString() {
return "Account{" +
"cardId='" + cardId + '\'' +
", money=" + money +
'}';
}
}
什么是线程池?
线程池就是一个可以复用线程的技术。
不使用线程池的问题
如果用户每发起一个请求、后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。
谁代表线程池?
JDK 5.0起提供了代表线程池的接口:ExecutorService
如何得到线程池对象
●方式一:使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
●方式二:使用Executors(线程池的工具类）调用方法返回不同特点的线程池对象
ThreadPoolExecutor构造器的参数说明
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
| 参数一:指定线程池的线程数量（核心线程) : corePoolSize | 不能小于0 |
| 参数二:指定线程池可支持的最大线程数:maximumPoolSize | 最大数量>=核心线程数量 |
| 参数三:指定临时线程的最大存活时间: keepAliveTime | 不能小于0 |
| 参数四:指定存活时间的单位(秒、分、时、天): unit | 时间单位 |
| 参数五:指定任务队列:workQueue | 不能为null |
| 参数六:指定用哪个线程工厂创建线程: threadFactory | 不能为null |
| 参数七:指定线程忙，任务满的时候，新任务来了怎么办: handler | 不能为null |
ExecutorService的常用方法
| 方法名称 | 说明 |
| void execute(Runnable command) | 执行任务/命令，没有返回值,一般用来执行Runnable任务 |
| Future<T> submit(Callable<T> task) | 执行任务。返回未来任务对象获取线程结果。一般拿来执行callable 任务 |
| void shutdown() | 等任务执行完毕后关闭E程池 |
| List<Runnable> shutdownNaw() | 立刻关闭。停止正在执行的任务，并返回队列中未执行的任务 |
MyRunnable
package d5_threadpool;
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 {
Thread.sleep(1000000);
System.out.println(Thread.currentThread().getName() + "线程进入休眠");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
ThreadPoolDemo
package d5_threadpool;
import java.util.concurrent.*;
public class ThreadPoolDemo1 {
public static void main(String[] args) {
//1.创建线程池对象
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();//会等待全部任务执行完毕之后再关闭（建议使用）
}
}
新任务拒绝策略
| 策略 | 详解 |
| ThreadPoo1Executor.AbortPolicy | 丢弃任务并抛出RejectedExecutionException异常。是默认的策略 |
| ThreadPoolExecutor.DiscardPolicy: | 丢弃任务，但是不抛出异常这是不推荐的做法 |
| ThreadPoolExecutor. Discard0ldestPolicy | 抛弃队列中等待最久的任务然后把当前任务加入队列中 |
| ThreadPoolExecutor.CallerRunsPolicy | 由主线程负责调用任务的run0方法从而绕过线程池直接执行 |
线程池常见面试：
临时线程什么时候创建啊?
新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
什么时候会开始拒绝任务?
核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。
定时器
定时器是一种控制任务延时调用，或者周期调用的技术。
作用:闹钟、定时邮件发送。
定时器的实现方式
方式一:Timer
方式二:ScheduledExecutorService
Timer定时器
package d6_timer;
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() + "执行一次");
}
},3000,2000);
}
}
Timer定时器的特点和存在的问题
1、Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。
2、可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。
ScheduledExecutorService定时器
ScheduledExecutorservice是jdk1.5中引入了并发包，目的是为了弥补Timer的缺陷,ScheduledExecutorService内部为线程池。
package d6_timer;
import java.util.Date;
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() + "执行输出：HHH ->" +new Date());
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},0,2, TimeUnit.SECONDS);
pool.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行输出：lll ->" +new Date());
}
},0,2, TimeUnit.SECONDS);
}
}
scheduledExecutorService的优点
基于线程池，某个任务的执行情况不会影响其他定时任务的执行。
并发与并行
正在运行的程序（软件）就是一个独立的进程，线程是属于进程的，多个线程其实是并发与并行同时进行的。
并发的理解:
CPU同时处理线程的数量有限。
CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。
并行的理解:
在同一个时刻上，同时有多个线程在被CPU处理并执行。
线程的状态
线程的状态:也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。理解线程的状态有利于提升并发编程的理解能力。
Java线程的状态
Java总共定义了6种状态
6种状态都定义在Thread类的内部枚举类中。
线程的6种状态总结
| 线程状态 | 描述 |
| NEW(新建) | 线程刚被创建，但是并未启动。 |
| Runnable(可运行) | 线程已经调用了start()等待CPU调度 |
| Blocked(锁阻塞) | 线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态;。 |
| waiting(无限等待) | 一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒 |
| Timed waiting(计时等待) | 超时参数的常用方法有Thread.sleep . object.wait。 |
| Teminated(被终止) | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。 |
3076
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
