第十四章、 线程(基础)

2024-08-29 21:52
文章标签 基础 线程 第十四章

本文主要是介绍第十四章、 线程(基础)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

第十四章、 线程(基础)

14.1 线程介绍

  1. 程序
    程序是为了完成特定任务、用某种语言编写的一组指令的集合
    简单来说：就是我们自己写的代码

  2. 进程
    （1）. 进程是指运行中的程序，比如我们使用的qq，就启动了一个进程，操作系统就会为进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。
    （2）. 进程是程序的一次执行过程，或者是正在运行的一个程序。是动态的过程：有它自身的产生、存在和消亡的过程。

  3. 什么是线程
    （1）. 线程由进程创建的，是进程的一个实体
    （2）. 一个进程可以拥有多个线程
    （3）. 例如：迅雷同时正在下载三个资源，那么那它有三个线程

  4. 线程的其他相关概念
    （1）. 单线程：同一时刻，只允许执行一个线程
    （2）. 多线程：同一时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件。
    （3）. 并发：同一时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单来说，单核cpu实现的多任务就是并发。
    （4）. 并行：同一时刻，多个任务同时执行。多核cpu可以实现并行。
    （5）. 也可能同时存在并行和并发。通过Java查看cpu核数
    在这里插入图片描述

package chapter14;/*** @aim java基础学习* @note java笔记*/
public class CpuNumber {public static void main(String[] args) {Runtime runtime=Runtime.getRuntime();//单例模式，只能通过方法获取对象int processors = runtime.availableProcessors();//获取当前电脑的cpu数量/核数System.out.println(processors);//12}
}

14.2 线程基本使用

  1. 创建线程的两种方式
    （1）. 继承Thread类，重写run方法
    （2）. 实现Runnable接口，重写方法

在这里插入图片描述2. 线程应用案例1-继承Thread类
（1）. 请编写程序，开启一个线程，该线程每隔1秒。在控制台输出“hello，你好。”
（2）. 当输出20次之后，自动结束该线程
（3）. 使用JConsole监控线程执行情况，并画出程序示意图
在这里插入图片描述

package chapter14.threaduse;/*** @aim java基础学习* @note java笔记*///当一个类继承了Thread类，该类就可以当做线程使用，
// 一般会重写run方法，写上相应的逻辑业务代码
// Thread类的run方法 是实现了Runnable接口的run方法
/*@Overridepublic void run() {if (target != null) {target.run();}}*/
public class Cat extends Thread{int times = 0;@Overridepublic void run() {//java中真正实现多线程是start中的start0()方法，run()方法知识一个普通方法，多线程高并发专题剖析while (true){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("hello,你好呀。"+ (++times)+" 线程名="+Thread.currentThread().getName() );if(times==80){//当times到10时，退出while，这时线程也就退出了..break;}}}
}
class TestThread{public static void main(String[] args) {//创建Cat对象，可以当做线程使用Cat cat = new Cat();cat.start();//启动线程->最终会执行cat的run方法/*源码解释(1)首先执行Thread类的start方法，然后在调用start0方法public synchronized void start() {start0();}(2)start0() 是本地方法，是有JVM调用的，底层是c/c++实现，真正实现多线程的效果，是start0()方法，而不是run()方法private native void start0();*///说明：当main线程启动一个子线程Thread-0 主线程不会阻塞(不会等其他线程执行完)，会继续执行后续代码//这时主线程和子线程会交替执行for (int i = 0; i < 50; i++) {System.out.println("主线程名"+Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

jconsole的使用监测

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
（5）. 对源码分析的图

在这里插入图片描述
start()方法调用start0()方法后，该线程不一定会立马执行，只是将线程变成了可运行状态。具体什么时候执行，取决于CPU，有CPU统一调度。

  1. 线程应用案例2-实现Runnable接口
    （1）. Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时再用继承Thread类方法来创建线程显然就不可能了。
    （2）. Java设计者就提供了另一个方式创建线程，就是通过实现Runnable接口来创建线程
    （3）. 请编写程序，该程序可以每隔1秒。在控制台输出“hi，你好”，当输出10次后，自动退出。请使用实现Runnable接口的方式来实现。这里底层使用了一种设计模式【静态代理】。
package chapter14.threaduse;/*** @aim java基础学习* @note java笔记* 通过实现接口Runnable 来开发线程*/
public class ThreadRunnable {public static void main(String[] args) {Dog dog = new Dog();
//        dog.start();//接口Runnable没有这个方法，无法调用Thread thread = new Thread(dog);thread.start();//模拟代理模式的静态模式
//        Tiger tiger = new Tiger();
//        ThreadProxy threadProxy = new ThreadProxy(tiger);
//        thread.run();}
}class Animal{}
class Tiger extends Animal implements Runnable{@Overridepublic void run() {System.out.println("老虎嗷嗷叫.....");}
}
//了解一下代理模式,模拟极简Thread类的代码模式
class ThreadProxy implements Runnable{//这里可以把ThreadProxy类当做 Threadprivate Runnable target=null;public ThreadProxy(Runnable target) {this.target = target;}@Overridepublic void run() {if (target != null) {target.run();}}public void start(){start0();}public void start0(){run();}
}class Dog implements Runnable {int times = 0;@Overridepublic void run() {//普通方法while (true) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("hi,你好呀" + (++times) + " 线程名=" + Thread.currentThread().getName());if (times == 10) {break;}}}
}
  1. 线程使用案例3-多线程执行
    请编写一个程序，创建两个线程，一个线程每隔一秒输出“hello，你好呀”，输出10次后自动退出；另一个线程每隔一秒输出“hi，你好呀”，输出5次后自动退出。Thread03.java
package chapter14.threaduse;/*** @aim java基础学习* @note java笔记* main线程启动两个子线程*/
public class Tread03 {public static void main(String[] args) {T3 t3 = new T3();Thread thread = new Thread(t3);thread.start();//启动第一个线程T4 t4 = new T4();t4.start();//启动第二个线程}
}
class T3 implements Runnable{int times=0;@Overridepublic void run() {while (true) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Hello,你好呀"+(++times)+" 线程名="+Thread.currentThread().getName());if (times==10) {break;}}}
}
class T4 extends Thread{int times=0;@Overridepublic void run() {while (true) {try {Thread.sleep(1000);} catch (Exception e) {e.printStackTrace();}System.out.println("hi,你好呀"+(++times)+" 线程名="+Thread.currentThread().getName());if (times==8) {break;}}}
}
  1. 继承Thread类和实现Runnable的区别
    （1）. 从Java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上是没有区别的【start()–>start0()】,从jdk帮助文档就可以看出Thread类本身就实现了Runnable接口。
    （2）. 实现Runnable接口的方式方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable。
Counter counter = new Counter();// 创建多个线程，并启动它们
Thread thread1 = new Thread(counter);
Thread thread2 = new Thread(counter);
Thread thread3 = new Thread(counter);thread1.start();
thread2.start();
thread3.start();
  1. 售票系统，编程模拟三个售票窗口进行售票，分别使用继承Thread和实现Runnable方式，并分析有什么问题？SellTicket.java
package chapter14.ticket_;/*** @aim java基础学习* @note java笔记**/
public class SellTicket {public static void main(String[] args) {
//        //测试继承Tread去售票
//        SellTicket01 sellTicket01 = new SellTicket01();//第一个窗口-线程
//        SellTicket01 sellTicket02 = new SellTicket01();//第二个窗口-线程
//        SellTicket01 sellTicket03 = new SellTicket01();//第三个窗口-线程
//        //当票不足3时，剩余1或2，若是三个线程都在这个时候再去售票并且都是同时通过了判断语句，那么就会出现票数为负数的情况
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();//测试实现Runnable接口去售票，由于也是三个线程在同时执行run代码，也会可能出现票数为负数这个问题的。SellTicket02 sellTicket02 = new SellTicket02();new Thread(sellTicket02).start();//第一个窗口-线程new Thread(sellTicket02).start();//第二个窗口-线程new Thread(sellTicket02).start();//第三个窗口-线程//关于上面的问题，在后面学到synchronized关键字再解决}
}
class SellTicket01 extends Thread{private static int ticketNum=100;@Overridepublic void run() {while (true) {if (ticketNum<=0) {System.out.println("对不起,没票啦");break;}try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 "+Thread.currentThread().getName()+"  售出一张票"+"剩余票数="+(--ticketNum));}}
}
class SellTicket02 implements Runnable{private static int ticketNum=100;@Overridepublic void run() {while (true) {if (ticketNum<=0) {System.out.println("对不起,没票啦");break;}try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 "+Thread.currentThread().getName()+"  售出一张票"+"剩余票数="+(--ticketNum));}}
}
  1. 线程终止
    基本说明
    （1）. 当线程完成任务后，会自动退出
    （2）. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
    （3）. 演示：启动一个线程t，要求在main线程中去停止线程t，请编程实现
package chapter14.exit_;/*** @aim java基础学习* @note java笔记* 演示线程终止*/
public class ThreadExit_ {public static void main(String[] args) {T t = new T();new Thread(t).start();//让mian线程循环30次就通知子线程t退出for (int i = 0; i <=60 ; i++) {try {Thread.sleep(50);//让main线程休眠50ms} catch (InterruptedException e) {e.printStackTrace();}System.out.println("main线程执行中...");if(i==30){t.setLoop(false);//通过设置loop变量中断T对象的线程--通知方式}}}
}
class T implements Runnable{private int times=0;//定义标记变量private boolean loop = true;@Overridepublic void run() {while (loop){try {Thread.sleep(50);//让当前线程休眠50ms} catch (InterruptedException e) {e.printStackTrace();}System.out.println("T方法执行中..."+(++times));}}public boolean isLoop() {return loop;}public void setLoop(boolean loop) {this.loop = loop;}
}

14.3 线程常用方法

  1. 常用方法第一组
    （1）. setName //设置线程名称，使之与参数name相同
    （2）. getName //返回该线程的名称
    （3）. start //使该线程开始执行，Java虚拟机底层调用该线程的start0()方法
    （4）. run //调用线程对象run方法
    （5）. setPriority //更改线程的优先级
    （6）. getPriority //获取线程的优先级
    （7）. sleep //在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
    （8）. interrupt // 中断线程，注意中断不是终止，而是中断休眠。
package chapter14.method_;/*** @aim java基础学习* @note java笔记* 演示线程的常用方法*/
public class ThreadMethod {public static void main(String[] args) throws InterruptedException {T t = new T();t.setName("Jack");t.setPriority(Thread.MIN_PRIORITY);t.start();//让main线程循环5次，之后就中断子线程for (int i = 1; i <= 5; i++) {Thread.sleep(1000);//alt+enter，将异常抛出，每秒询问一次System.out.println("请问我可以吃一个吗？"+i);}System.out.println(t.getName()+" t线程的优先级 = "+t.getPriority());System.out.println(Thread.currentThread().getName()+" main线程的优先级 = "+t.getPriority());t.interrupt();}
}class T extends Thread{@Overridepublic void run() {while (true) {for (int i = 1; i <= 100; i++) {//Thread.currentThread().getName() 获取当前线程的名称System.out.println(Thread.currentThread().getName()+" 吃包子......"+i);}try {System.out.println(Thread.currentThread().getName() +" 休眠中");Thread.sleep(20000);} catch (InterruptedException e) {//当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入到自己的业务逻辑代码//InterruptedException 是捕获到一个中断异常System.out.println("睡眠被Interrupt了");}}}
}
  1. 注意事项和细节
    （1）. start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程。
    （2）. 线程优先级的范围

在这里插入图片描述
（3）. interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠的线程，【理解：让线程从休眠中醒来，执行后续代码】
（4）. sleep：线程的静态方法，使当前线程休眠

  1. 常用方法第二组
    （1）. yield：线程的礼让。让出cpu，让其他线程执行，但礼让时间不确定，所以也不一定礼让成功。
    （2）. join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有任务。
    （3）. 案例：main线程创建一个子线程，每隔一秒输出hello，输出20次；主线程每隔一秒输出hi，输出20次。要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续。
    在这里插入图片描述
package chapter14.method_;/*** @aim java基础学习* @note java笔记*/
public class ThreadMethod02 {public static void main(String[] args) throws InterruptedException {T1 t1 = new T1();t1.start();for (int i = 1; i <= 20; i++) {Thread.sleep(1000);if(i==6){t1.join();//t1线程插队Thread.yield();//当前线程做出礼让,但不一定成功}  System.out.println(Thread.currentThread().getName()+"吃包子"+i);}}
}
class T1 extends Thread{@Overridepublic void run() {for (int i = 1; i <= 20; i++) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"吃包子..."+i);}}
}
/*
main吃包子1
Thread-0吃包子...1
Thread-0吃包子...2
main吃包子2
main吃包子3
Thread-0吃包子...3
Thread-0吃包子...4
main吃包子4
Thread-0吃包子...5
main吃包子5
Thread-0吃包子...6
Thread-0吃包子...7
Thread-0吃包子...8
Thread-0吃包子...9
Thread-0吃包子...10
Thread-0吃包子...11
Thread-0吃包子...12
Thread-0吃包子...13
Thread-0吃包子...14
Thread-0吃包子...15
Thread-0吃包子...16
Thread-0吃包子...17
Thread-0吃包子...18
Thread-0吃包子...19
Thread-0吃包子...20
main吃包子6
main吃包子7
main吃包子8
main吃包子9
main吃包子10
main吃包子11
main吃包子12
main吃包子13
main吃包子14
main吃包子15
main吃包子16
main吃包子17
main吃包子18
main吃包子19
main吃包子20*/
  1. 线程插队练习
    （1）. 主线程每隔1s，输出hi，一共10次
    （2）. 当输出到hi 5时，启动一个子线程（要求实现Runnable），每隔1s输出hello，等线程输出10次hello后，退出。
    （3）. 当子线程结束后，主线程继承输出，直到主线程退出
package chapter14.method_;/*** @aim java基础学习* @note java笔记*/
public class ThreadMethodExercise {public static void main(String[] args) throws InterruptedException {T2 t2 = new T2();Thread thread = new Thread(t2);for (int i = 1; i <= 10; i++) {Thread.sleep(1000);if(i==6){thread.start();//启动子线程thread.join();//可以理解：main线程主动让t2线程插队}System.out.println("hi "+i);}System.out.println("main线程结束");}
}class T2 implements Runnable{@Overridepublic void run() {for (int i = 1; i <= 10; i++) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("hello "+i);}System.out.println("子线程结束");}
}
/*
hi 1
hi 2
hi 3
hi 4
hi 5
hello 1
hello 2
hello 3
hello 4
hello 5
hello 6
hello 7
hello 8
hello 9
hello 10
子线程结束
hi 6
hi 7
hi 8
hi 9
hi 10
main线程结束*/
  1. 用户线程和守护线程
    （1）. 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
    （2）. 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
    （3）. 常见的守护线程：垃圾回收机制
    案例：比如：main线程有一个子线程，这个子线程是无限循环输出。默认当main线程结束，子线程也会继续运行，那么程序也会一直运行。现打算在main线程结束，程序也跟着的结束，不管子线程是否还在运行。那么将子线程设置为守护线程即可。
package chapter14.method_;/*** @aim java基础学习* @note java笔记* 演示守护线程*/
public class ThreadMethod03 {public static void main(String[] args) throws InterruptedException {MyDaemonThread thread = new MyDaemonThread();//将MyDaemonThread线程设置为守护线程，当所有线程结束后，thread也就自动结束//如果没有设置，那么即使main线程执行完毕，thread也不退出thread.setDaemon(true);thread.start();//需要先设置守护线程，然后再启动线程，否则可能会报错for (int i = 1; i <= 10; i++) {Thread.sleep(1000);System.out.println("Lucy and Rose etc hi...");}}
}
class MyDaemonThread extends Thread{@Overridepublic void run() {for (;;){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Jack,hi...");}}
}

14.4 线程生命周期

  1. JDK中用Thread.State枚举表示了线程的几种状态。查API
    在这里插入图片描述
  2. 线程状态转换图

在这里插入图片描述

  1. 写程序查看线程状态
package chapter14.state_;/*** @aim java基础学习* @note java笔记*/
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()) {//检查线程 t 当前的状态是否不是 TERMINATED,这里Thread.State是个枚举类System.out.println(t.getName() + " 状态=" + t.getState());Thread.sleep(1000);}System.out.println(t.getName() + " 状态=" + t.getState());}
}class T extends Thread {@Overridepublic void run() {while (true) {for (int i = 0; i < 3; i++) {System.out.println("hi " + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}break;}}
}

14.5 Synchronied

  1. 线程同步
    前面留下了一个问题：售票问题。现在在这里解决。

  2. 线程同步机制
    （1）. 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
    （2）. 也可以这样理解：线程同步，即当一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。
    （3）. 铭记同步的意思。即保证数据在任何同一时刻，最多有一个线程访问。

  3. 同步具体方法-Synchronized
    （1）. 同步代码块
    synchronized(对象) { //得到对象的锁，才能操作同步代码
    //需要被同步代码;
    }
    （2）. synchronized 还可以放在方法声明中，表示整个方法-为同步方法
    public synchronized void m(String name){
    //需要被同步的代码
    }
    （3）. 如何理解：就好像上厕所，某人上厕所前就会先把门关上（上锁），完事后再出来（解锁），那么其他就可以使用厕所。
    （4）. 使用是synchronized将 售票问题解决

package chapter14.syn_;/*** @aim java基础学习* @note java笔记* 使用synchronized同步方法*/
public class SellTicket {public static void main(String[] args) {//有时候可能会出现只有一个进程在买票，是因为对象锁是非公平锁的，谁抢到谁使用 SellTicket03 sellTicket03 = new SellTicket03();new Thread(sellTicket03).start();//第一个窗口-线程new Thread(sellTicket03).start();//第二个窗口-线程new Thread(sellTicket03).start();//第三个窗口-线程}
}//实现接口方式，使用synchronized实现线程同步
class SellTicket03 implements Runnable {private static int ticketNum = 100;private boolean loop=true;public synchronized void sell() { //同步方法，在同一时刻，只能有一个线程来执行sell方法if (ticketNum <= 0) {System.out.println("对不起,没票啦");loop=false;return;}try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 " + Thread.currentThread().getName() + "  售出一张票" + "剩余票数=" + (--ticketNum));}@Overridepublic void run() {while (loop) {sell();}}
}
  1. 同步原理
    （1）. 锁的概念：在Java中，每个对象都有一个内置的锁（也称为监视器锁）。当一个线程需要访问某个对象的同步方法或代码块时，它必须首先获取该对象的锁。
    （2）. 锁定机制：synchronized 关键字用于在方法上创建一个锁。在你的 SellTicket03 类中，sell() 方法被标记为 synchronized，这意味着每次只有一个线程可以进入这个方法。当一个线程进入 sell() 方法时，它会获得 SellTicket03 实例上的锁（即 this 锁）。其他线程必须等待，直到这个线程释放锁。
    （3）. 线程互斥：如果两个或多个线程同时尝试调用 sell() 方法，由于方法是同步的，只有一个线程能成功获取到锁并执行方法。其他线程会被阻塞，直到锁被释放。

14.6 互斥锁

  1. 基本介绍
    （1）. Java在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
    （2）. 每个对象都对英语一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
    （3）. 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
    （4）. 同步的局限性：导致程序的执行效率要降低。
    （5）. 同步方法（非静态的）的锁可以是this，也可以是其他对象（要求是同一个对象）
    （6）. 同步方法（静态的）的锁为当前类本身。
package chapter14.syn_;/*** @aim java基础学习* @note java笔记* 使用synchronized同步代码块*/
public class SellTicket02 {public static void main(String[] args) {SellTicket04 sellTicket04 = new SellTicket04();new Thread(sellTicket04).start();//第一个窗口-线程new Thread(sellTicket04).start();//第二个窗口-线程new Thread(sellTicket04).start();//第三个窗口-线程}
}class SellTicket04 implements Runnable {private static int ticketNum = 100;private boolean loop = true;Object object = new Object();//同步方法（静态的）的锁为当前类本身。// 1.public synchronized static void m1(){} 锁是加在SellTicket04.class// 2.如果是在静态方法，实现一个同步代码块，那么锁也是SellTicket04.classpublic synchronized static void m1(){}public static void m2(){synchronized (SellTicket04.class){System.out.println("hello");}}//这样上锁对吗，答案是不对。//原因是 当创建下面两个线程时，它们的对象都是不一样，那么锁也是不一样的。肯定是锁不住的。//会造成什么问题：这两个线程会同时出售买票// new Thread(sellTicket04).start();// new Thread(sellTicket04).start();public void m3(){synchronized (this){System.out.println("hello");}}@Overridepublic void run() {while (loop) {//这里的object是定义为属性，因为只new了一次所以正确的。要是在这里换成了new Object()就不对了synchronized (/*this*/ object) { // (this) 表示对当前对象实例的锁定，互斥锁是this对象.也开始是其他对象锁if (ticketNum <= 0) {System.out.println("对不起,没票啦");loop = false;return;}try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票 剩余票数=" + (--ticketNum));}}}
}
  1. 注意事项和细节
    （1）. 同步方法如果没有使用static修饰：默认锁对象为this
    （2）. 如果方法使用static修饰，默认锁对象：当前类.class
    （3）. 实现的落地步骤：
    ① 需要先分析上锁的代码
    ② 选择同步代码块或同步方法
    ③ 要求多个线程的锁对象为同一个即可。
    在这里插入图片描述在这里插入图片描述

14.7 死锁

  1. 基本介绍
    多个线程都占用了对方的锁资源，但不肯不让，导致了死锁，在编程是一定要避免死锁的发生。
  2. 应用案例：
    妈妈：你先完成作业，才让你玩手机
    小明：你先让我玩手机，我才完成作业。
package chapter14.syn_;/*** @aim java基础学习* @note java笔记* 演示线程死锁*/
public class DeadLock_ {public static void main(String[] args) {DeadLockDemo deadLockDemo1 = new DeadLockDemo(true);DeadLockDemo deadLockDemo2 = new DeadLockDemo(false);deadLockDemo1.setName("线程A");deadLockDemo1.start();deadLockDemo2.setName("线程B");deadLockDemo2.start();}
}
class DeadLockDemo extends Thread{static Object o1 = new Object();//保证多线程，共享一个对象，这里使用staticstatic Object o2 = new Object();boolean flag;public DeadLockDemo(boolean flag){this.flag=flag;}//1.如果flag为T, 假设线程A会先得到/持有 o1对象锁, 然后尝试去获取o2对象锁,//2.如果线程A 得不到o2线程锁，就会一直在Blocked//3.如果flag为F, 假设线程B会先得到/持有 o2对象锁, 然后尝试去获取o1对象锁,//4.如果线程B 得不到o1线程锁，就会一直在Blocked@Overridepublic void run() {if(flag){synchronized (o1){//对象互斥锁，下面是同步代码System.out.println(Thread.currentThread().getName()+"进入1");synchronized (o2){//这里获得li对象的监视权System.out.println(Thread.currentThread().getName()+"进入2");}}}else{synchronized (o2){System.out.println(Thread.currentThread().getName()+"进入1");synchronized (o1){//这里获得li对象的监视权System.out.println(Thread.currentThread().getName()+"进入2");}}}}
}

  1. 释放锁
    （1）. 当前线程的同步代码块、同步方法执行结束。比如上厕所，完事出来
    （2）. 当前线程在同步代码块、同步方法中遇到了break、return。案例：没有正常的完事，被别人强迫叫出来，不得已出来。
    （3）. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。案例：没有正常完事，发现忘记带纸，不得已出来
    （4）. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。案例：没有正常完事，觉得需要酝酿下，所以出来等会再进入。

  2. 不会释放锁的情况
    （1）. 线程执行同步代码或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁。案例：上厕所，太困了，不出来咪了一会。
    （2）. 线程执行同步代码或同步方法时，其他线程调用了该线程的suspend()方法将线程挂起，该线程不会释放锁。提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

14.8 本章作业

  1. 编程题 Task.java
    （1）. 在main方法中启动两个线程
    （2）. 第一个线程循环随机打印100以内的整数
    （3）. 直到第2个线程从键盘读取“Q”命令。
package chapter14.task_;import java.util.Scanner;/*** @aim java基础学习* @note java笔记*/
public class Task01 {public static void main(String[] args) {ThreadFor threadFor = new ThreadFor();new Thread(threadFor).start();new Thread(new ThreadQ(threadFor)).start();}
}class ThreadFor implements Runnable{private boolean flag=true;@Overridepublic void run() {while (flag) {int i= (int) (100*Math.random()+1);System.out.println(i);try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("ThreadFor线程已退出");}public void setFlag(boolean flag) {this.flag = flag;}
}
class ThreadQ implements Runnable{private ThreadFor threadFor;private Scanner scanner = new Scanner(System.in);public ThreadQ(ThreadFor threadFor) {this.threadFor = threadFor;}@Overridepublic void run() {while (true){System.out.println("请输入你的指令(Q)表示退出:");char key = scanner.next().toUpperCase().charAt(0);if(key=='Q'){threadFor.setFlag(false);System.out.println("ThreadQ已退出");break;}}}
}
  1. 编程题 Task02.java
    （1）. 有2个用户分别从同一个卡上取钱（总额：10 000）
    （2）. 每次都领取1000，当余额不足时，就不能取款了
    （3）. 不能出现超取现象 ->线程同步问题
package chapter14.task_;/*** @aim java基础学习* @note java笔记* 题不难,但要理解原理即可*/
public class Task02 {public static void main(String[] args) {BankCard user1 = new BankCard();//这里注意不要new两次然后去创建线程，因为同步方法不是静态的，那么锁对象就是this。// 如果new了两次，那么就会产生两个对象，即两个不同的锁对象，使用new Thread(user1);和 new Thread(user2);是错误的。
//        BankCard user2 = new BankCard();Thread thread1 = new Thread(user1);Thread thread2 = new Thread(user1);thread1.setName("Jack");thread2.setName("Rose");thread1.start();thread2.start();}
}class BankCard implements Runnable {private static int balance = 10000;private boolean loop = true;//当多个线程执行到这里时，就会争夺 this对象锁.若某线程获得锁就直到代码执行完就释放锁public synchronized void withdrawal() {if (balance < 1000) {System.out.println(Thread.currentThread().getName()+"说,余额不足1000");loop = false;return;}balance -= 1000;System.out.println(Thread.currentThread().getName() + "取款1000 ,余额=" + balance);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}@Overridepublic void run() {while (loop) {withdrawal();}}
}
/*
Rose取款1000 ,余额=9000
Jack取款1000 ,余额=8000
Rose取款1000 ,余额=7000
Rose取款1000 ,余额=6000
Jack取款1000 ,余额=5000
Jack取款1000 ,余额=4000
Rose取款1000 ,余额=3000
Rose取款1000 ,余额=2000
Jack取款1000 ,余额=1000
Jack取款1000 ,余额=0
Jack说,余额不足1000
Rose说,余额不足1000*/

这篇关于第十四章、 线程(基础)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1118963。

相关文章

mysql的基础语句和外键查询及其语句详解(推荐)

mysql的基础语句和外键查询及其语句详解(推荐)

《mysql的基础语句和外键查询及其语句详解(推荐)》：本文主要介绍mysql的基础语句和外键查询及其语句详解(推荐),本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋... 目录一、mysql 基础语句1. 数据库操作 创建数据库2. 表操作 创建表3. CRUD 操作二、外键
阅读更多...
Python基础语法中defaultdict的使用小结

Python基础语法中defaultdict的使用小结

《Python基础语法中defaultdict的使用小结》Python的defaultdict是collections模块中提供的一种特殊的字典类型,它与普通的字典（dict）有着相似的功能,本文主要... 目录示例1示例2python的defaultdict是collections模块中提供的一种特殊的字
阅读更多...
Python基础文件操作方法超详细讲解(详解版)

Python基础文件操作方法超详细讲解(详解版)

《Python基础文件操作方法超详细讲解(详解版)》文件就是操作系统为用户或应用程序提供的一个读写硬盘的虚拟单位,文件的核心操作就是读和写,：本文主要介绍Python基础文件操作方法超详细讲解的相... 目录一、文件操作1. 文件打开与关闭1.1 打开文件1.2 关闭文件2. 访问模式及说明二、文件读写1.
阅读更多...
Spring Boot3虚拟线程的使用步骤详解

Spring Boot3虚拟线程的使用步骤详解

《SpringBoot3虚拟线程的使用步骤详解》虚拟线程是Java19中引入的一个新特性,旨在通过简化线程管理来提升应用程序的并发性能,：本文主要介绍SpringBoot3虚拟线程的使用步骤,... 目录问题根源分析解决方案验证验证实验实验1：未启用keep-alive实验2：启用keep-alive扩展建
阅读更多...
C#基础之委托详解(Delegate)

C#基础之委托详解(Delegate)

《C#基础之委托详解(Delegate)》：本文主要介绍C#基础之委托(Delegate),具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录1. 委托定义2. 委托实例化3. 多播委托（Multicast Delegates）4. 委托的用途事件处理回调函数LINQ
阅读更多...
Java终止正在运行的线程的三种方法

Java终止正在运行的线程的三种方法

《Java终止正在运行的线程的三种方法》停止一个线程意味着在任务处理完任务之前停掉正在做的操作,也就是放弃当前的操作,停止一个线程可以用Thread.stop()方法,但最好不要用它,本文给大家介绍了... 目录前言1. 停止不了的线程2. 判断线程是否停止状态3. 能停止的线程–异常法4. 在沉睡中停止5
阅读更多...
Java捕获ThreadPoolExecutor内部线程异常的四种方法

Java捕获ThreadPoolExecutor内部线程异常的四种方法

《Java捕获ThreadPoolExecutor内部线程异常的四种方法》这篇文章主要为大家详细介绍了Java捕获ThreadPoolExecutor内部线程异常的四种方法,文中的示例代码讲解详细,感... 目录方案 1方案 2方案 3方案 4结论方案 1使用 execute + try-catch 记录
阅读更多...
Spring Boot 中正确地在异步线程中使用 HttpServletRequest的方法

Spring Boot 中正确地在异步线程中使用 HttpServletRequest的方法

《SpringBoot中正确地在异步线程中使用HttpServletRequest的方法》文章讨论了在SpringBoot中如何在异步线程中正确使用HttpServletRequest的问题,... 目录前言一、问题的来源：为什么异步线程中无法访问 HttpServletRequest？1. 请求上下文与线
阅读更多...
在 Spring Boot 中使用异步线程时的 HttpServletRequest 复用问题记录

在 Spring Boot 中使用异步线程时的 HttpServletRequest 复用问题记录

《在SpringBoot中使用异步线程时的HttpServletRequest复用问题记录》文章讨论了在SpringBoot中使用异步线程时,由于HttpServletRequest复用导致... 目录一、问题描述：异步线程操作导致请求复用时 Cookie 解析失败1. 场景背景2. 问题根源二、问题详细分
阅读更多...
0基础租个硬件玩deepseek,蓝耘元生代智算云|本地部署DeepSeek R1模型的操作流程

0基础租个硬件玩deepseek,蓝耘元生代智算云|本地部署DeepSeek R1模型的操作流程

《0基础租个硬件玩deepseek,蓝耘元生代智算云|本地部署DeepSeekR1模型的操作流程》DeepSeekR1模型凭借其强大的自然语言处理能力,在未来具有广阔的应用前景,有望在多个领域发... 目录0基础租个硬件玩deepseek,蓝耘元生代智算云|本地部署DeepSeek R1模型，3步搞定一个应
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2