多线程二——常用方法、生命周期、互斥锁、死锁与释放锁
线程的终止
1、当线程完成任务后，就会自动退出
2、还可以通过使用变量来控制run方法退出的方式停止线程。
案例：
启动一个线程，然后在main线程中去停止子线程（**我们直线在子线程上设置一个变量，直接让循环开关关闭 **）
/**
* @author 喂S别闹
* @create 2021/11/10-8:59
* @Version 1.0
* @Description: 线程的退出
*/
public class ThreadExit {
public static void main(String[] args) {
T t = new T();
t.start();
//如果希望主线程去控制t线程的终止，那么我们就需要去修改loop变量
//让t退出run方法，从而 终止t线程的循环
//让主线程休眠10S，再通知退出
try {
System.out.println("主线程休眠10S");
Thread.sleep(10 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
t.setLoop(false);
}
}
class T extends Thread {
int count = 0;
//设置一个控制变量
private boolean loop = true;
@Override
public void run() {
while (loop) {
try {
Thread.sleep(50);//休眠50ms
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread...运行中" + ++count);
}
}
public void setLoop(boolean loop) {
this.loop = loop;
}
}
线程的常用方法
第一组常规方法以及Interrupt的用法
- setName ： 设置线程的名称
- getName
- start：使该线程开始执行；Java虚拟机底层调用该线程的start（）方法
- run：调用线程对象的run方法
- setPriority ：更改线程的优先级
- getPriority：获取线程的优先级
- sleep：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
- interrupt：中断线程
注意细节：
1、start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新的线程
2、线程优先级的范围
3、interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠的线程
4、sleep：线程的静态方法，使当前线程休眠
Interrupt的用法
/**
* @author 喂S别闹
* @create 2021/11/17-11:30
* @Version 1.0
* @Description: Interrup中断线程的使用
*/
public class ThreadInterrupt {
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
t1.setName("喂S别闹");
t1.setPriority(Thread.MIN_PRIORITY);
t1.start();
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("主线程" + i);
}
System.out.println(t1.getName() + "线程的优先级是：" + t1.getPriority());
t1.interrupt(); //当执行到这里的时候就会中断T1线程的休眠
}
}
class T1 extends Thread {
@Override
public void run() {
while (true) {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "线程运行..." + i);
}
try {
System.out.println(Thread.currentThread().getName() + "休眠~~");
Thread.sleep(20000);
} catch (InterruptedException e) {
//当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
//InterruptedException 是捕获到一个中断异常
e.printStackTrace();
}
}
}
}
常用方法第二组yield与join
1、yield：线程的礼让。让出 CPU，让其他线程去执行，但礼让的时间不确定，所有也不一定礼让成功。（t1线程和t2线程，如果t1线程执行yield，那么就是t1线程主动礼让t2线程先执行，但是如果CPU运行得快，有足够时间，那么礼让就会不成功）
2、Join；线程的插队。插队的线程一旦插入成功，则肯定会先执行插入的线程所有任务（比如有t1和t2两个线程在交替执行，如果在t1线程中执行t2.join（）方法，那么CPU就会直接会把t2线程完，然后再执行t1）
例子练习
题目：
1、主线程每隔1s，输出hi，一共10次
2、当输出5次hi的时候，启动一个子线程（要求实现Runnable），每隔1s输出Hello，等该线程输出10次hello后退出
3、主线程继续输出hi，直到主线程退出
比如：
hi1
hi2
hi3
hi4
hi5
子线程结束
hello1
hello2
。。。
hello10
hi6
..
hi10
主线程结束
代码：
/**
* @author 喂S别闹
* @create 2021/11/17-14:17
* @Version 1.0
* @Description: 主线程和子线程交替使用的练习
* 1、主线程每隔1s，输出hi，一共10次
* <p>
* 2、当输出5次hi的时候，启动一个子线程（要求实现Runnable），每隔1s输出Hello，等该线程输出10次hello后退出
* <p>
* 3、主线程继续输出hi，直到主线程退出
*/
public class ThreadMethodExercise {
public static void main(String[] args) throws InterruptedException {
/* T3 t3 = new T3();
Thread t4 = new Thread(t3);*/
Thread t3 = new Thread(new T3());
for (int i = 1; i <= 10; i++) {
System.out.println("Hi" + i);
if (i == 5) {//说明主线程输出了5次
t3.start(); //启动子线程 输出Hello
t3.join(); //立即将t3子线程，插入到main线程，让t3先执行
}
}
}
}
class T3 implements Runnable {
private int count = 0;
@Override
public void run() {
while (true) {
System.out.println("Hello" + ++count);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10) {
break;
}
}
}
}
常用方法：用户线程和守护线程
1、用户线程：也叫工程线程，当线程的任务执行完或通知方式结束
2、守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程就自动结束。
3、常见的守护线程：垃圾回收机制
案例：测试如何将一个线程设置成守护线程
/**
* @author 喂S别闹
* @create 2021/11/17-15:38
* @Version 1.0
* @Description: 将一个线程设置成为守护线程
*/
public class ThreadMethod03 {
public static void main(String[] args) throws InterruptedException {
MyDaemonThread myDaemonThread = new MyDaemonThread();
//如果希望当主线程结束之后，子线程就会自动结束
//只需将子线程设为守护线程即可
myDaemonThread.setDaemon(true);
myDaemonThread.start();
for (int i = 1; i <= 10; i++) {
System.out.println("主线程");
Thread.sleep(1000);
}
}
}
class MyDaemonThread extends Thread {
@Override
public void run() {
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("哈哈哈哈");
}
}
}
线程的生命周期（中间有个图很重要）
JDK中用Thread.State枚举表示了线程的几种状态
在官方文档里，是有6种线程状态的
1、new：尚未开启线程处于此状态
2、Runnable ：在Java虚拟机中执行的线程处于此状态(注意runnable状态不是正在运行状态 ，只是表示可以运行了，具体运行还需要看线程调度器来控制)
3、Blocked：被阻塞等待监视器锁定的线程处于此状态
4、waiting：正在等待另一个线程执行特定动作的线程处于此状态
5、Time_waiting：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态（超时等待）
6、Terminated：已退出的线程处于此状态
图很重要
例子：
/**
* @author 喂S别闹
* @create 2021/11/17-16:18
* @Version 1.0
* @Description: 线程的状态展示
*/
public class ThreadState {
public static void main(String[] args) throws InterruptedException {
T t = new T();
System.out.println(t.getName() + "状态" + t.getState());
t.start();
while (Thread.State.TERMINATED != t.getState()) {
System.out.println(t.getName() + "状态" + t.getState());
Thread.sleep(500);
}
System.out.println(t.getName() + "状态" + t.getState());
}
}
class T extends Thread {
@Override
public void run() {
while (true) {
for (int i = 0; i < 10; i++) {
System.out.println("hi " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
}
}
Synchronized关键词
线程同步机制
1、在多线程编程中，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
2、简单说：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进程操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。
同步具体方法--Synchronized
1、同步代码块
synchronized（对象）{//得到对象的锁，才能操作同步代码
//需要被同步代码；
}
2、synchronized还可以放在方法声明中，表示整个方法-为同步方法
public synchronized void m(String name){
//需要被同步的代码
}
例子
public class SellTicket {
public static void main(String[] args) {
//测试同步
SellTicket03 sellTicket03 = new SellTicket03();
new Thread(sellTicket03).start(); //第一个线程
new Thread(sellTicket03).start(); //第2个线程
new Thread(sellTicket03).start(); //第3个线程
}
}
//实现runnable接口,使用synchronized实现线程同步
class SellTicket03 implements Runnable {
private int Ticketnum = 100; //让多个线程共享
private boolean loop = true;
public synchronized void sell(){ //同步方法，在同一时刻，只能有一个线程来执行run方法
if (Ticketnum <= 0) {
System.out.println("售票结束了");
loop=false;
return;
}
//休眠
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 卖出了一张票 " + "还剩" + (--Ticketnum) + "张票");
}
@Override
public void run() {
while (loop) {
sell();
}
}
}
分析同步原理
互斥锁
基本介绍：
1、Java中，引入了对象互斥锁的概念，来保证共享数据操作的完整性
2、每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
3、关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
4、同步的局限性：导致程序的执行效率要降低
5、同步方法（非静态的类）的锁可以是this，也可以是其他对象（但必须是同一对象）
6、同步方法（静态的类）的锁为当前类本身。
使用互斥锁来解决售票问题
可以在代码块上加锁
public class SellTicket {
public static void main(String[] args) {
//测试同步
SellTicket03 sellTicket03 = new SellTicket03();
new Thread(sellTicket03).start(); //第一个线程
new Thread(sellTicket03).start(); //第2个线程
new Thread(sellTicket03).start(); //第3个线程
}
}
//实现runnable接口,使用synchronized实现线程同步
class SellTicket03 implements Runnable {
private int Ticketnum = 100; //让多个线程共享
private boolean loop = true;
Object object = new Object();
public /*synchronized*/ void sell() { //同步方法，在同一时刻，只能有一个线程来执行run方法
synchronized (/*this*/ object) {
if (Ticketnum <= 0) {
System.out.println("售票结束了");
loop = false;
return;
}
//休眠
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 卖出了一张票 " + "还剩" + (--Ticketnum) + "张票");
}
}
@Override
public void run() {
while (loop) {
sell();
}
}
}
静态类方法
public class SellTicket {
public static void main(String[] args) {
//测试同步
SellTicket03 sellTicket03 = new SellTicket03();
new Thread(sellTicket03).start(); //第一个线程
new Thread(sellTicket03).start(); //第2个线程
new Thread(sellTicket03).start(); //第3个线程
}
}
//实现runnable接口,使用synchronized实现线程同步
class SellTicket03 implements Runnable {
private int Ticketnum = 100; //让多个线程共享
private boolean loop = true;
//同步方法静态的类的锁为当前类的本身
//1、 public synchronized static void m1(){} 锁是在SellTicket03.class
// 2、如果在静态方法中，实现同步代码块，就是类名.class
// public static void m2(){
// synchronized (SellTicket03.class){
// System.out.println("1");
// }
// }
public synchronized static void m1(){
}
public static void m2(){
synchronized (SellTicket03.class){
System.out.println("1");
}
}
互斥锁注意事项
1、同步方法如果没有使用static修饰：默认锁对象为this
2、如果方法使用了static修饰，默认锁对象：当前类.class
3、实现：
- 需要先分析上锁业务代码
- 选择同步代码块还是同步方法
- 要求多个线程的锁对象为同一个即可。
线程的死锁
介绍
多个线程都占用了对方的锁资源，但不肯相互让步，导致了死锁，在平时编程时是我们一定要避免的。
释放锁
释放锁的操作
1、当前线程的同步方法、同步代码块执行结束
2、当前线程在同步代码块、同步方法中遇到break、return
3、当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
4、当前线程在同步代码块、同步方法中执行了线程对象的wait（）方法，当前线程暂停，并释放锁
不会释放锁的操作
1、线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁。
2、线程执行同步代码块时，其他线程调用了该线程的suspend（）方法将该线程挂起，该线程不会释放锁。
注意：尽量避免用suspend（）和resume（）来控制线程，方法不再推荐使用
