---

一、概念

1、进程

• 进程就是正在运行中的程序

2、线程

• 是1个进程（程序内部）的1条执行路径
• 单线程：1个进程中只有1个线程（1条执行路径）
• 多线程：1个进程中包含多个线程（多条执行路径）
• 线程之间堆内存、方法区内存共享；但是栈内存独立，1个线程一个栈

3、CPU与线程的关系

1. 单核CPU：不能够做到真正的多线程并发，因为在一个时间单元内，只能执行一个线程的任务，多个线程谁获取时间片运行谁，每个线程获取时间片的概率相等，可能：t1、t2、t2、t2；给人一种多线程并发的感觉：其实是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是多个事情同时在做

4、并行、并发

1. 并行：多核CPU同时执行多个任务。比如：多个人同时做不同的事
2. 并发：单核CPU同时执行多个任务。比如：多个人做同一件事

5、线程的生命周期

1. 新建状态
   • 新建了线程对象，还没调用start方法
2. 就绪状态
   • 线程调用了start方法等待获取CPU时间片
   • 表示当前线程具有抢夺CPU时间片的权力
3. 运行状态
   • 线程对象开始执行run方法
   • run方法的开始执行标志着这个线程进入运行状态，当之前占有的CPU时间片用完之后，会重新回到就绪状态继续抢夺CPU时间片，当再次抢到CPU时间之后，会重新进入run方法接着上一次的代码继续往下执行
4. 阻塞状态
   • 当一个线程遇到阻塞事件，例如：sleep方法、获取synchronized排他锁失败(因为锁被其它线程所占用)等，此时线程会进入阻塞状态，阻塞状态的线程会放弃之前占有的CPU时间片，之前的时间片没了需要再次回到就绪状态抢夺CPU时间片
5. 死亡状态
   • run方法执行完毕或者因异常退出了run方法，该线程生命周期结束

二、创建

1、继承Thread

• class Thread implements Runnable
• 缺点：
  • 由于java是单继承的，这导致继承了Thread后就不能在继承其它类了；在实际开发中会经常继承某个超类来复用其中的方法，这导致两者不能同时继承
  • 继承线程后重写run方法来定义任务，这又导致我们将任务直接定义在线程上使得线程只能做该任务，无法并发执行其他任务，重用性变差

public class HandleMsg extends Thread{/** 线程标识 */private String threadKey;/** 构造方法用来区分不同线程便于测试 */public HandleMsg(String threadKey){this.threadKey=threadKey;}@Overridepublic void run(){for(int i=0;i<10;i++){System.err.println(threadKey+"：run");}}}//匿名内部类lambda
Thread t1=new Thread(()->{for(int i=0;i<10;i++) {System.err.println("t1：run");}
};//创建2个线程对象
HandleMsg h1=new HandleMsg("h1");
HandleMsg h2=new HandleMsg("h2");//启动线程，开始执行实现的run方法
h1.start();
h2.start();

2、实现Runnable接口

• 优点：线程和线程执行的任务分离

public class HandleMsg implements Runnable{/** 线程标识 */private String threadKey;/** 构造方法用来区分不同线程便于测试 */public HandleMsg(String threadKey){this.threadKey=threadKey;}@Overridepublic void run(){for(int i=0;i<10;i++){System.err.println(threadKey+"：run");}}}//创建2个任务对象
HandleMsg h1=new HandleMsg("h1");
HandleMsg h2=new HandleMsg("h2");//将任务1交给线程1
Thread t1=new Thread(h1);
//将任务2交给线程2
Thread t2=new Thread(h2);//启动线程，开始执行任务的run方法
t1.start();
t2.start();

3、实现Callable接口

• FutureTask implements RunnableFuture，RunnableFuture<V> extends Runnable
• 优点
  • 线程和线程执行的任务分离
  • 有返回值
  • 可以声明抛出的异常

//Callable的泛型就是重写的call方法的返回值类型
public class HandleMsg implements Callable<String>{/** 线程标识 */private String threadKey;/** 构造方法用来区分不同线程便于测试 */public HandleMsg(String threadKey){this.threadKey=threadKey;}@Overridepublic String call() throws Exception{for(int i=0;i<10;i++){System.err.println(threadKey+"：run");}return threadKey;}}//创建2个任务对象
HandleMsg h1=new HandleMsg("h1");
HandleMsg h2=new HandleMsg("h2");//创建FutureTask类包装任务对象，泛型就是任务类实现Callable的泛型，也就是call方法返回值的类型
FutureTask<String> f1=new FutureTask<>(h1);
FutureTask<String> f2=new FutureTask<>(h2);//将FutureTask对象交给线程
Thread t1=new Thread(f1);
Thread t2=new Thread(f2);//启动线程，开始执行任务的run方法
t1.start();
t2.start();//获取返回值
String result1=f1.get();
String result2=f2.get();

三、API

1、获取运行使用的线程

//在哪个方法执行就获取执行该方法的线程
Thread thread=Thread.currentThread();

2、唯一标识

long getId();

3、线程名

String getName();//线程启动之前可以设置线程名
void setName(String name);

4、优先级

• 线程有10个优先级，用1-10表示，默认为5

int getPriority();//启动之前设置
//线程无法主动获取cpu时间片，唯一可以干涉线程调度工作的方式就是修改线程的优先级，最大程度的改善获取cpu时间片的几率，理论上，线程优先级越高的线程获取cpu时间片的次数越多
void setPriority(int newPriority);

5、是否处于活动状态

boolean isAlive();

6、守护线程

• 守护线程又称为后台线程，默认创建出来的线程都是普通线程或称为前台线程
• 当进程结束时，所有正在运行的守护线程都会被强制中断
• 进程的结束：当一个进程中没有任何前台线程时即结束
• main主线程就是前台线程，不受其他线程影响，分配其他线程后接着干自己的事，其他线程执行的时候，main线程可能已经结束了

//是否为守护线程
boolean isDaemon();//启动之前设置
void setDaemon(boolean on);

7、join

• 作用是：让当前执行的线程陷入等待（内部调用了wait方法）。
  • 永久等待：其实现原理是不停的检查当前线程是否存活，该线程的任务执行完毕后就会处于死亡状态，如果存活则说明任务还未执行完毕-继续等待
• 线程启动之后调用

1、API

//等待线程执行完任务后再往下执行，join(0);
void join();//等待线程执行一段时间后再往下执行，无论线程任务是否执行完毕，单位：毫秒
void join(long millis);

2、有无join对比

//1、程序正常运行顺序是不会等待线程任务执行完毕，就会往下执行
Thread t1=new Thread(()->{for(int i=0;i<5;i++){System.err.println(i);}
});
t1.start();System.err.println("next task");// 输出结果
//		next task
//		0
//		1
//		2
//		3
//		4//2、调用join
Thread t1=new Thread(()->{for(int i=0;i<5;i++){System.err.println(i);}
});
t1.start();t1.join();System.err.println("next task");//		0
//		1
//		2
//		3
//		4
//		next task

8、yield

• 线程让步
• 暂停（不是终止）当前正在执行的线程任务，让其它具有相同优先级或更高优先级的等待的线程执行任务（其它也会包含暂停的线程，所以有可能刚暂停就执行）
• 暂停的线程状态变化：运行状态 -> 就绪状态
• 暂停期间不会释放锁，所以其他线程获取不到锁

9、sleep

• 使线程睡眠
• sleep的睡眠期间不会释放锁，所以其它线程获取不到锁
• 睡眠线程的状态变化：运行状态 -> 阻塞状态 -> 就绪状态

//Thread的静态方法，单位：毫秒
static void sleep(long millis) throws InterruptedException;

• sleep和wait的区别

sleep	wait
属于Thread类	属于Object类
可以在任何地方使用	wait、notify、notifyAll 只能在同步方法、同步控制块里面使用
睡眠期间不会释放锁	会释放锁，而且会将当前线程加入到等待队列中
不需要唤醒	可以被notify、notifyAll唤醒

10、线程中断

• 只是打断线程的睡眠，不会终止线程的继续执行

//线程是否中断
boolean isInterrupted();//中断线程睡眠
Thread t1=new Thread(()->{System.err.println("run......");try{//睡眠10sThread.sleep(10000L);}catch(InterruptedException e){e.printStackTrace();}System.err.println("end......");
});//启动线程
t1.start();//中断睡眠
//线程不会睡眠10s，而是被中断，抛出InterruptedException，捕获该异常后，继续执行后续的代码
t1.interrupt();System.err.println("next task");// 执行结果
//		next task
//		run......
//		end......