✨✨个人主页:沫洺的主页
📚📚系列专栏: 📖 JavaWeb专栏📖 JavaSE专栏 📖 Java基础专栏📖vue3专栏
📖MyBatis专栏📖Spring专栏📖SpringMVC专栏📖SpringBoot专栏
📖Docker专栏📖Reids专栏📖MQ专栏📖SpringCloud专栏
💖💖如果文章对你有所帮助请留下三连✨✨
💐多线程
🍁多线程基本概念
什么是多线程
- 是指从软件或者硬件上实现多个线程并发执行的技术。
- 具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。
串行：
- 串行就是顺序执行，指令必须按照先后顺序来执行，前面的程序段执行完了，后面的程序段才能执行
并行：
- 在同一时刻，有多个指令在多个CPU上同时执行。
并发：
- 在同一时刻，有多个指令在单个CPU上交替执行。
同步：
- 同步就是当A请求一个资源的时候，这个资源正在被B使用，那么A就必须要等待，等到B使用完了A才能请求到
异步：
- 异步就是当A请求一个资源的时候，这个资源正在被B使用，A不需要等也可以请求到
程序：
- 一个程序可以有多个进程
- 程序是一段静态的代码，它是应用程序执行的蓝本
进程：
- 进程是指一种正在运行的程序，有自己的地址空间。
- 作为蓝本的程序可以被多次加载到系统的不同内存区域分别执行，形成不同的进程。
- 基于进程的特点是允许计算机同时运行两个或更多的程序。
- 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
- 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的
- 并发性：任何进程都可以同其他进程一起并发执行
线程：
- 单线程：一个进程如果只有一条执行路径，则称为单线程程序
- 多线程：一个进程如果有多条执行路径，则称为多线程程序
🌿实现多线程
🌳方式一：继承Thread类
方法介绍
方法名 说明 void run() 在线程开启后，此方法将被调用执行 void start() 使此线程开始执行，Java虚拟机会调用run方法() 实现步骤
定义一个类MyThread继承Thread类
在MyThread类中重写run()方法
测试类中创建MyThread类的对象
启动线程
代码演示
package com.moming1; public class MyThread extends Thread{ @Override public void run() { System.out.println("既是线程类又是任务类"); } }package com.moming1; public class Test { public static void main(String[] args) { MyThread mt1 = new MyThread(); MyThread mt2 = new MyThread(); //void run 在线程开启后，此方法将被调用执行 //单线程 mt1.run(); mt2.run(); //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法 //多线程 mt1.start(); mt2.start(); } }既是线程类又是任务类 既是线程类又是任务类 既是线程类又是任务类 既是线程类又是任务类注意事项
为什么要重写run()方法？
因为run()是用来封装被线程执行的代码
run()方法和start()方法的区别？
run()：封装线程执行的代码，直接调用，相当于普通方法的调用
start()：启动线程；然后由JVM调用此线程的run()方法
还有就是为什么说直接调用run()是单线程操作，JVM调用线程run()是多线程操作
首先对MyThread类添加一个有参构造(参数为name)，设置线程名称
🍂设置和获取线程名称
方法介绍
方法名 说明 void setName(String name) 将此线程的名称更改为等于参数name String getName() 返回此线程的名称 Thread currentThread() 返回对当前正在执行的线程对象的引用
package com.moming1; 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()+"执行了"); } } }package com.moming1; public class Test { public static void main(String[] args) { //通过有参构造实例化设置名字 MyThread mt1 = new MyThread("线程一"); MyThread mt2 = new MyThread("线程二"); //通过set设置名字 //mt1.setName("线程一"); //mt2.setName("线程二"); //void run 在线程开启后，此方法将被调用执行 //单线程 mt1.run(); mt2.run(); //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法 //多线程 mt1.start(); mt2.start(); } }main执行了 main执行了 main执行了 main执行了 main执行了 main执行了 main执行了 main执行了 main执行了 main执行了 线程一执行了 线程一执行了 线程一执行了 线程二执行了 线程二执行了 线程一执行了 线程一执行了 线程二执行了 线程二执行了 线程二执行了可以看到多线程的执行顺序是并发的，而单线程就是串行的
🌲方法二：实现Runnable接口
Thread构造方法
方法名 说明 Thread(Runnable target) 分配一个新的Thread对象 Thread(Runnable target, String name) 分配一个新的Thread对象 实现步骤
定义一个类MyRunnable实现Runnable接口
在MyRunnable类中重写run()方法
在测试类中创建MyRunnable类的对象
创建Thread类的对象，把MyRunnable对象作为构造方法的参数
启动线程
代码演示
package com.moming2; public class MyRunnable implements Runnable{ @Override public void run() { System.out.println("任务类被"+Thread.currentThread().getName()+"执行了"); } }package com.moming2; public class Test { public static void main(String[] args) { //创建MyRunnable类的对象 MyRunnable mr = new MyRunnable(); //创建Thread类的对象，把MyRunnable对象作为构造方法的参数 Thread t1 = new Thread(mr); Thread t2 = new Thread(mr,"线程二"); Thread t3 = new Thread(mr); //启动线程 t1.start(); t2.start(); t3.start(); } }任务类被线程二执行了 任务类被Thread-1执行了 任务类被Thread-0执行了
- 这种线程实现方法，扩展性强，实现该接口的同时还可以继承其他的类
注意
- 线程对象默认是有名字的，也可以通过Thread的有参构造设置线程名
🍃方法三：实现Callable接口
方法介绍
方法名 说明 V call() 计算结果，如果无法计算结果，则抛出一个异常 FutureTask(Callable<V> callable) 创建一个 FutureTask，一旦运行就执行给定的 Callable V get() 如有必要，等待计算完成，然后获取其结果 实现步骤
- 定义一个类MyCallable实现Callable接口，泛型默认Object，需指定泛型
- 在MyCallable类中重写call()方法
- 创建MyCallable类的对象
- 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
- 创建Thread类的对象，把FutureTask对象作为构造方法的参数
- 启动线程
- 再调用get方法，就可以获取线程结束之后的结果。
代码演示
package com.moming3; import java.util.concurrent.Callable; public class MyCallable implements Callable<String> { @Override public String call() throws Exception { System.out.println("任务类被"+Thread.currentThread().getName()+"执行了"); return "有返回值的任务类"; } }package com.moming3; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class Test { public static void main(String[] args) throws ExecutionException, InterruptedException { MyCallable mc = new MyCallable(); //创建一个 FutureTask，一旦运行就执行给定的 Callable FutureTask<String> ft = new FutureTask(mc); Thread t1 = new Thread(ft); t1.start(); //如有必要，等待计算完成，然后获取其结果 String s = ft.get(); System.out.println(s); } }任务类被Thread-0执行了 有返回值的任务类
🌾线程休眠
相关方法
方法名 说明 static void sleep(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数 代码演示
package com.moming4; import java.util.Date; public class SleepThreadDemo extends Thread{ @Override public void run() { for (int i=0; i<5;i++) { try { //使当前正在执行的线程停留（暂停执行）指定的毫秒数 Thread.sleep(1000);//有异常用try-catch包裹一下 } catch (InterruptedException e) { e.printStackTrace(); } System.out.printf("%tT%n",new Date()); } } }package com.moming4; public class Test { public static void main(String[] args) { SleepThreadDemo sto = new SleepThreadDemo(); sto.start(); } }12:43:42 12:43:43 12:43:44 12:43:45 12:43:46这里设置了1000毫秒的休眠，所以循环输出的时间间隔就是1秒
三种线程实现方式对比
实现Runnable、Callable接口
好处: 扩展性强，实现该接口的同时还可以继承其他的类
缺点: 编程相对复杂，不能直接使用Thread类中的方法
继承Thread类
好处: 编程比较简单，可以直接使用Thread类中的方法
缺点: 可以扩展性较差，不能再继承其他的类
🌺线程优先级
线程调度
两种调度方式
分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
Java使用的是抢占式调度模型
随机性
假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的
优先级相关方法
方法名 说明 final int getPriority() 返回此线程的优先级 final void setPriority(int newPriority) 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10 代码演示
package com.moming5; import java.util.concurrent.Callable; public class MyCallable implements Callable<String> { @Override public String call() throws Exception { for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName()+"执行了"); } return "执行完毕"; } }package com.moming5; import java.util.concurrent.FutureTask; public class Test { public static void main(String[] args) { MyCallable mc = new MyCallable(); FutureTask<String> ft1 = new FutureTask<>(mc); Thread t1 = new Thread(ft1,"线程一"); FutureTask<String> ft2 = new FutureTask<>(mc); Thread t2 = new Thread(ft2,"线程二"); //查看优先级 System.out.println(t1.getPriority()); System.out.println(t2.getPriority()); //设置优先级 t1.setPriority(10); t2.setPriority(1); //开启线程 t1.start(); t2.start(); } }5 5 线程一执行了 线程二执行了 线程一执行了 线程二执行了 线程二执行了 线程一执行了 线程二执行了 线程二执行了 线程一执行了 线程二执行了 线程二执行了 线程一执行了 线程二执行了 线程一执行了 线程二执行了 线程一执行了 线程二执行了 线程一执行了 线程一执行了 线程一执行了可以看到默认优先级是5，设置优先级之后其实没多大影响，优先级高的线程获取的 CPU 时间片相对多一些，但是多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的
🌸守护线程
相关方法
方法名 说明 void setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出 代码演示
package com.moming6; //主线程 public class MyThread1 extends Thread{ @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName()+"执行了"+i); } } }package com.moming6; //主线程 public class MyThread1 extends Thread{ @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName()+"执行了"+i); } } }package com.moming6; public class Test { public static void main(String[] args) { MyThread1 mt1 = new MyThread1(); MyThread2 mt2 = new MyThread2(); mt1.setName("主线程"); mt2.setName("守护线程"); //设置守护线程 //当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了. mt2.setDaemon(true); mt1.start(); mt2.start(); } }主线程执行了0 主线程执行了1 守护线程执行了0 主线程执行了2 守护线程执行了1 主线程执行了3 守护线程执行了2 主线程执行了4 守护线程执行了3 主线程执行了5 守护线程执行了4 主线程执行了6 守护线程执行了5 主线程执行了7 守护线程执行了6 主线程执行了8 守护线程执行了7 主线程执行了9 守护线程执行了8 守护线程执行了9 守护线程执行了10 守护线程执行了11 守护线程执行了12 守护线程执行了13 守护线程执行了14 守护线程执行了15可以看到主线程结束后，守护线程并不会立即停止
🌼线程安全问题
卖票应用
案例需求
某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
实现步骤
定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
在SellTicket类中重写run()方法实现卖票，代码步骤如下
判断票数大于0，就卖票，并告知是哪个窗口卖的
卖了票之后，总票数要减1
票卖没了，线程停止
定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
创建SellTicket类的对象
创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
启动线程
代码实现
package com.moming7; public class SellTicket implements Runnable { private int tickets = 100; @Override public void run() { while (true){ if(tickets>0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } tickets--; System.out.println(Thread.currentThread().getName()+"售票中，还剩"+tickets); }else { break; } } } }package com.moming7; public class SellTicketDemo { public static void main(String[] args) { SellTicket st = new SellTicket(); Thread t1 = new Thread(st,"窗口一"); Thread t2 = new Thread(st,"窗口二"); Thread t3 = new Thread(st,"窗口三"); t1.start(); t2.start(); t3.start(); } }运行结果出现问题
问题一：有重复的
问题二：出现负数剩余票
问题产生原因：
是多线程环境
线程执行的随机性导致的,可能在卖票过程中丢失cpu的执行权,导致出现问题
有共享数据
有多条语句操作共享数据
解决多线程安全问题
- 首先共享数据用static修饰
- 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可，Java提供了同步代码块的方式来解决
🌹synchronized(对象)方法
同步代码块
synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
- 对于实例方法建议使用this作为锁对象。
- 对于静态方法建议使用字节码（类名.class）对象作为锁对象。
作用：把出现线程安全问题的核心代码给上锁。
原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行
synchronized(任意对象) { 多条语句操作共享数据的代码 }同步的好处和弊端
好处：解决了多线程的数据安全问题
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
代码演示
这样就解决了以上出现的问题
当然了能同步代码块也能同步方法
作用：把出现线程安全问题的核心方法给上锁。
原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。
同步方法：就是把synchronized关键字加到方法上
同步方法的格式
修饰符 synchronized 返回值类型 方法名(方法参数) { 方法体； }同步方法的锁对象是：this
静态同步方法
同步静态方法：就是把synchronized关键字加到静态方法上
修饰符 static synchronized 返回值类型 方法名(方法参数) { 方法体； }同步静态方法的锁对象：类名.class
代码演示
- 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
- 如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！
- 如果方法是静态方法：同步方法默认用类名.class作为的锁对象。
🌻 Lock锁
为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。
Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。
构造方法
方法名称
说明
public ReentrantLock()
获得Lock锁的实现类对象
Lock的API
方法名称
说明
void lock()
获得锁
void unlock()
释放锁
package com.moming7; import java.util.concurrent.locks.ReentrantLock; public class SellTicket implements Runnable { private static int tickets = 100; ReentrantLock rl = new ReentrantLock(); @Override public void run() { while (true) { rl.lock(); try { if (tickets > 0) { Thread.sleep(100); tickets--; System.out.println(Thread.currentThread().getName() + "售票中，还剩" + tickets); } else { break; //System.exit(0); } } catch (InterruptedException e) { e.printStackTrace(); } finally { rl.unlock(); } } } }
🌷死锁
概述
线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行
什么情况下会产生死锁
- 资源有限
- 同步嵌套
代码演示
public class Demo { public static void main(String[] args) { Object objA = new Object(); Object objB = new Object(); new Thread(()->{ while(true){ synchronized (objA){ //线程一 synchronized (objB){ System.out.println("小康同学正在走路"); } } } }).start(); new Thread(()->{ while(true){ synchronized (objB){ //线程二 synchronized (objA){ System.out.println("小薇同学正在走路"); } } } }).start(); } }
package deadlock; import java.lang.management.ManagementFactory; import java.lang.management.ThreadInfo; import java.lang.management.ThreadMXBean; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; /** * 线程死锁 * 定位死锁 * 第一种方法：cmd窗口->jps->jstack 线程ID * 第二种方法：可视化窗口jconsole */ /** * 预防死锁 * 避免多锁 * 设计好锁的获取顺序 * 使用超时方法 * 死锁检测 */ public class DeadLock { public static void main(String[] args) { //产生死锁 deadLockFun(); //第三种方法(java提高的标准API)ThreadMXBean ThreadMXBean mxBean= ManagementFactory.getThreadMXBean(); //将检测线程死锁的任务放在线程任务里 Runnable target=new Runnable() { @Override public void run() { //获取死锁线程的ID数组 long[] deadlockedThreads = mxBean.findMonitorDeadlockedThreads(); if(deadlockedThreads!=null){ //通过死锁ID获取死锁线程 ThreadInfo[] threadInfo = mxBean.getThreadInfo(deadlockedThreads); System.out.println("检测到的所有死锁"); for (ThreadInfo info : threadInfo) { System.out.println(info.getThreadId() + "---" + info.getThreadName()); } } } }; //使用线程池 //定时触发线程池 ScheduledExecutorService service = Executors.newScheduledThreadPool(1); //五秒执行一次 service.scheduleAtFixedRate(target, 5, 5, TimeUnit.SECONDS); } public static void deadLockFun(){ final String STR1 = "网球场"; final String STR2 = "羽毛球场"; Thread thread1 = new Thread(){ @Override public void run() { synchronized (STR1){ System.out.println("线程1------"+STR1); synchronized (STR2){ System.out.println("线程1------"+STR2); } } } }; Thread thread2 = new Thread(){ @Override public void run() { synchronized (STR2){ System.out.println("线程2------"+STR2); synchronized (STR1){ System.out.println("线程2------"+STR1); } } } }; thread1.setName("way1_thread"); thread2.setName("thread2"); thread1.start(); thread2.start(); } }以上补充了三种找死锁的方法，感兴趣的可以试试
🍁生产者消费者模式
生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻
概述
所谓生产者消费者问题，实际上主要是包含了两类线程：
- 一类是生产者线程用于生产数据
- 一类是消费者线程用于消费数据
为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为
Object类的等待和唤醒方法
方法名 说明 void wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法 void notify() 唤醒正在等待对象监视器的单个线程 void notifyAll() 唤醒正在等待对象监视器的所有线程 案例
案例需求
桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量
生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务
1.判断是否有包子,决定当前线程是否执行
2.如果有包子,就进入等待状态,如果没有包子,继续执行,生产包子
3.生产包子之后,更新桌子上包子状态,唤醒消费者消费包子
消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务
1.判断是否有包子,决定当前线程是否执行
2.如果没有包子,就进入等待状态,如果有包子,就消费包子
3.消费包子后,更新桌子上包子状态,唤醒生产者生产包子
测试类(Test)：里面有main方法，main方法中的代码步骤如下
创建生产者线程和消费者线程对象
分别开启两个线程
代码实现
桌子类(Desk)
package com.moming8; public class Desk { //定义桌子上能放几个包子 public static int count = 1; //标记桌子上有无包子 public static boolean mark = false; //锁对象 public static final Object lock = new Object(); }生产者类(Cooker)
package com.moming8; public class Cooker implements Runnable{ @Override public void run() { while (true){ synchronized (Desk.lock) { if(!Desk.mark){ System.out.println(Thread.currentThread().getName()+"生产包子"); Desk.count++; Desk.mark=true; Desk.lock.notifyAll(); }else { try { Desk.lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } }消费者类(Foodie)
package com.moming8; public class Foodie implements Runnable { @Override public void run() { while (true) { synchronized (Desk.lock) { if (Desk.count == 0) { break; } else { if (Desk.mark) { System.out.println(Thread.currentThread().getName() + "吃包子"); Desk.count--; Desk.mark = false; Desk.lock.notifyAll(); } else { try { Desk.lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } } }测试类(Test)
package com.moming8; public class Test { public static void main(String[] args) { Cooker c = new Cooker(); Foodie f = new Foodie(); Thread t1 = new Thread(c,"厨师"); Thread t2 = new Thread(f,"吃货"); t1.start(); t2.start(); } }
扫一扫
4144
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
