当前位置： 首页 > ops >正文

JavaSe之多线程

ops 2025/9/5 21:22:43

一、多线程基本了解

1、多线程基本知识

1.进程:进入到内存中执行的应用程序
2.线程:内存和CPU之间开通的通道->进程中的一个执行单元
3.线程作用:负责当前进程中程序的运行.一个进程中至少有一个线程,一个进程还可以有多个线程,这样的应用程序就称之为多线程程序
4.简单理解:进程中的一个功能就需要一条线程去执行

在这里插入图片描述

2、并发和并行

1.并行:并行:在同一个时刻,有多个指令在多个CPU上(指多核即几核几线程)执行(好比是多个人做不同的事儿)
比如:多个厨师在炒多个菜
2.并发:并发:在同一个时刻,有多个指令在单个CPU上(交替)执行
比如:一个厨师在炒多个菜

细节:1.之前CPU是单核,但是在执行多个程序的时候好像是在同时执行,原因是CPU在多个线程之间做高速切换2.现在咱们的CPU都是多核多线程的了,比如2核4线程,那么CPU可以同时运行4个线程,此时不用切换,但是如果多了,CPU就要切换了,所以现在CPU在执行程序的时候并发和并行都存在

3、CPU调度

1.分时调度:让所有的线程轮流获取CPU使用权,并且平均分配每个线程占用CPU的时间片
2.抢占式调度:多个线程抢占CPU使用权,哪个线程优先级越高,先抢到CPU使用权的几率就大,但是不是说每次先抢到CPU使用权的都是优先级高的线程,只是优先级高的线程先抢到CPU使用权的几率会大一些 -> java代码(抢占式调度)

4、主线程介绍

主线程:为main方法服务的线程

二、创建线程的方式(重点)

1、第一种方式_extends Thread

1.定义一个类,继承Thread类
2.重写Thread类中的run方法,设置线程任务(该线程要做的事儿)
3.创建自定义线程类对象
4.调用Thread类中的start方法start()开启线程,jvm会自动执行run方法

定义线程对象

public class Day15Thread extends Thread {@Overridepublic void run(){for (int i = 0; i < 5; i++) {System.out.println("MyThread执行了:"+i);}}}

定义主线程

public class Day15ThreadText {public static void main(String[] args) {Day15Thread t1 = new Day15Thread();//t.run();t1.start();//开启线程,jvm自动执行run方法for (int i = 0; i < 5; i++) {System.out.println("main...执行了"+i);}}
}运行结果:
MyThread执行了:0
MyThread执行了:1
main...执行了0
main...执行了1
main...执行了2
MyThread执行了:2
MyThread执行了:3
MyThread执行了:4
main...执行了3
main...执行了4

注意：如果直接调用run方法,并不代表将线程开启,仅仅是简单的调用方法 > > 只有调用start方法,线程才会真正开启

2、多线程在内存中的运行原理

首先会内存会开启一个栈供main方法执行，此时main方法中的start()方法被调用，调用后内存会重新开启一个栈供新的线程运行

3、Thread中常用方法

void start() -> 开启线程,jvm自动调用run方法
void run()  -> 设置线程任务,这个run方法是Thread重写的接口Runnable中的run方法
String getName()  -> 获取线程名字
void setName(String name) -> 给线程设置名字
static Thread currentThread() -> 获取正在执行的线程对象(此方法在哪个线程中使用,获取的就是哪个线程对象)
static void sleep(long millis)->线程睡眠,超时后自动醒来继续执行,传递的是毫秒值

定义自定义线程

public class Day15Thread extends Thread {@Overridepublic void run(){for (int i = 0; i < 5; i++) {try {Thread.sleep(1000L);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName()+"执行了:"+i);}}
}

定义主线程

public class Day15ThreadText {public static void main(String[] args) throws InterruptedException {Day15Thread t1 = new Day15Thread();//t.run();t1.setName("刘大胆");t1.start();//开启线程,jvm自动执行run方法for (int i = 0; i < 5; i++) {Thread.sleep(1000L);System.out.println("主线程名称为"+Thread.currentThread().getName()+i);}}
}

> 1.父类方法抛异常了,子类重写之后可抛可不抛 > > 父类方法没有抛异常,子类重写之后不要抛 > > 2.重写了run方法之后,由于Thread中的run方法没有throws,那么我们重写run之后就不能throws,只能try

4、Thread其他方法

void setPriority(int newPriority)   -> 设置线程优先级,优先级越高的线程,抢到CPU使用权的几率越大,但是不是每次都先抢到int getPriority()  -> 获取线程优先级void setDaemon(boolean on)  -> 设置为守护线程,当非守护线程执行完毕,守护线程就要结束,但是守护线程也不是立马结束,当非守护线程结束之后,系统会告诉守护线程人家结束了,你也结束吧,在告知的过程中,守护线程会执行,只不过执行到半路就结束了static void yield() -> 礼让线程,让当前线程让出CPU使用权void join() -> 插入线程或者叫做插队线程
4.1 线程优先级
public class Day15ThreadText {public static void main(String[] args) throws InterruptedException {Day15Thread t1 = new Day15Thread();//t.run();t1.setName("刘大胆");Day15Thread t2 = new Day15Thread();t2.setName("超级刘大胆");t1.setPriority(Thread.MIN_PRIORITY);  //设置优先级t2.setPriority(Thread.MAX_PRIORITY);t1.start();//开启线程,jvm自动执行run方法t2.start();System.out.println(t1.getPriority()); //获取优先级System.out.println(t2.getPriority());for (int i = 0; i < 5; i++) {System.out.println("主线程名称为"+Thread.currentThread().getName()+i);}}
}
输出结果:
1
10
超级刘大胆执行了:0
主线程名称为main0
超级刘大胆执行了:1
主线程名称为main1
超级刘大胆执行了:2
主线程名称为main2
超级刘大胆执行了:3
主线程名称为main3
超级刘大胆执行了:4
主线程名称为main4
刘大胆执行了:0
刘大胆执行了:1
刘大胆执行了:2
刘大胆执行了:3
刘大胆执行了:4
4.2 守护线程

定义自定义线程1

public class Day15Thread1 extends Thread {@Overridepublic void run(){for (int i = 0; i < 10; i++) {System.out.println(getName()+"执行了:"+i);}}}

定义自定义线程2

public class Day15Thread2  extends Thread{@Overridepublic void run(){for (int i = 0; i <100; i++) {System.out.println(getName()+"执行了:"+i);}}
}

定义主线程

public class Day15ThreadText {public static void main(String[] args) throws InterruptedException {Day15Thread1 t1 = new Day15Thread1();//t.run();t1.setName("刘大胆");Day15Thread2 t2 = new Day15Thread2();t2.setName("超级刘大胆");//设置t2为守护线程t2.setDaemon( true);t1.start();//开启线程,jvm自动执行run方法t2.start();}
}
输出结果:超级刘大胆执行了:0
刘大胆执行了:0
超级刘大胆执行了:1
刘大胆执行了:1
超级刘大胆执行了:2
刘大胆执行了:2
超级刘大胆执行了:3
刘大胆执行了:3
超级刘大胆执行了:4
刘大胆执行了:4
超级刘大胆执行了:5
刘大胆执行了:5
超级刘大胆执行了:6
刘大胆执行了:6
超级刘大胆执行了:7
刘大胆执行了:7
超级刘大胆执行了:8
刘大胆执行了:8
超级刘大胆执行了:9
刘大胆执行了:9
超级刘大胆执行了:10
超级刘大胆执行了:11
超级刘大胆执行了:12
超级刘大胆执行了:13
超级刘大胆执行了:14
超级刘大胆执行了:15
超级刘大胆执行了:16
超级刘大胆执行了:17
超级刘大胆执行了:18
超级刘大胆执行了:19

由此可见 当非守护线程结束后 守护线程不会直接结束 而是执行一段时间后再结束

4.3 礼让线程
场景说明:如果两个线程一起执行,可能会执行一会儿线程A,再执行一会线程B,或者可能线程A执行完毕了,线程B再执行那么我们能不能让两个线程尽可能的平衡一点 -> 尽量让两个线程交替执行
注意:只是尽可能的平衡,不是绝对的你来我往,有可能线程A线程执行,然后礼让了,但是回头A又抢到CPU使用权了   

public class MyThread extends Thread{@Overridepublic void run() {for (int i = 0; i<= 10; i++) {System.out.println(Thread.currentThread().getName()+"...执行了"+i);//礼让线程Thread.yield();}}
}

public class Demo01Thread {public static void main(String[] args){MyThread t1 = new MyThread();//设置线程名字t1.setName("赵四");MyThread t2 = new MyThread();t2.setName("广坤");t1.start();//开启线程,jvm自动执行run方法t2.start();//开启线程,jvm自动执行run方法}
}
4.4 插入线程
public class MyThread extends Thread{@Overridepublic void run() {for (int i = 0; i <= 10; i++) {System.out.println(Thread.currentThread().getName()+"...执行了"+i);}}
}

public class Demo01Thread {public static void main(String[] args) throws InterruptedException {MyThread t = new MyThread();//设置线程名字t.setName("赵四");t.start();//开启线程,jvm自动执行run方法/*join(),插入线程将t1插入到当前线程前面,现在只有两条线程,一个t1,一个主线程我们想将t1插入到主线程前面,主线程就是当前线程*/t.join();for (int i = 0; i <= 10; i++) {System.out.println(Thread.currentThread().getName()+"...执行了"+i);}}
}

5、第二种方式_实现Runnable接口

1.创建一个自定义类,实现Runnable接口
2.重写run方法,设置线程任务
3.创建自定义类对象
4.利用Thread类的构造,创建Thread对象 ->Thread(Runnable r)Thread t1 = new Thread(自定义类对象)
5.调用start方法,开启线程

定义实现类

public class Day15Runnable implements Runnable{@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println(Thread.currentThread().getName()+"执行了:"+i);}}
}

定义主线程

，public class DayRunnableThread {public static void main(String[] args) {Day15Runnable t1 = new Day15Runnable();/*Thread(Runnable r)Thread(Runnable r,String name) -&gt; 创建Thread对象的同时给线程设置名字*/Thread t = new Thread(t1);t.start();for (int i = 0; i < 5; i++) {System.out.println(Thread.currentThread().getName()+"执行了:"+i);}}
}

6、两种实现多线程的方式区别

1.继承Thread: 由于继承只能进行单继承，会有很大的局限性

2.实现Runnable: 可以继承一个父类的同时实现一个或者多个接口,没有继承的局限性

7、匿名内部类创建多线程

package com.code.day15;public class Day15RunnableNI {public static void main(String[] args) {new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println(Thread.currentThread().getName()+"执行了:"+i);}}}).start();
//Thread(Runnable r ,String name)new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println(Thread.currentThread().getName()+"执行了:"+i);}}},"超级刘大胆").start();}
}

三、线程安全

1.线程不安全原因

出现线程不安全的原因:多个线程同时访问同一个资源

线程不安全代码

public class Day15Safe implements Runnable {int ticket = 100;@Overridepublic void run() {while (true) {if (ticket > 0) {System.out.println(Thread.currentThread().getName() + "...买了第" + ticket + "张票");ticket--;}}}
}
package com.code.day15;public class Day15SafeTest {public static void main(String[] args) {Day15Safe t = new Day15Safe();Thread t1 = new Thread(t,"赵四");Thread t2 = new Thread(t,"广坤");Thread t3 = new Thread(t,"刘能");t1.start();t2.start();t3.start();}
}

2.解决线程安全问题的第一种方式(使用同步代码块)

1.格式:synchronized(锁对象){可能出现线程不安全的代码}2.锁对象:a.任意对象b.想要实现线程安全,多个线程之间用的锁对象就必须是同一个锁对象3.线程执行,抢到锁进入同步代码块执行,其他线程等待排队,需要等着执行的线程出了同步代码块,将锁释放,其他等待线程才能抢锁,进入到同步代码块中执行

定义自定义线程及锁

package com.code.day15;public class Day15Safe implements Runnable {int ticket = 100;Object obj = new Object();@Overridepublic void run() {while (true) {try {Thread.sleep(1000L);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (obj){if (ticket > 0) {System.out.println(Thread.currentThread().getName() + "...买了第" + ticket + "张票");ticket--;}}}}
}

测试

package com.code.day15;public class Day15SafeTest {public static void main(String[] args) {Day15Safe t = new Day15Safe();Thread t1 = new Thread(t,"赵四");Thread t2 = new Thread(t,"广坤");Thread t3 = new Thread(t,"刘能");t1.start();t2.start();t3.start();}
}
输出结果:
赵四...买了第100张票
刘能...买了第99张票
广坤...买了第98张票
刘能...买了第97张票
赵四...买了第96张票
广坤...买了第95张票
广坤...买了第94张票
刘能...买了第93张票
赵四...买了第92张票 ......

3.解决线程安全问题的第二种方式:同步方法

3.1普通同步方法_非静态

定义锁

package com.code.day15;public class Day15Safe implements Runnable {int ticket = 100;Object obj = new Object();@Overridepublic void run() {while (true) {try {Thread.sleep(1000L);} catch (InterruptedException e) {throw new RuntimeException(e);}method();}}public synchronized void method() {if (ticket > 0) {System.out.println(Thread.currentThread().getName() + "...买了第" + ticket + "张票");ticket--;}//三个对象共享一个锁
//    public void method() {
//        synchronized (this) { 
//            if (ticket > 0) {
//                System.out.println(Thread.currentThread().getName() + "...买了第" + ticket + "张票");
//                ticket--;
//            }
//        }
//    }}
}
3.2静态同步方法
1.格式:修饰符 static synchronized 返回值类型 方法名(形参){方法体return 结果}2.默认锁:当前类.class -> class对象,现在先记住,class对象在 反射会讲

package com.code.day15;public class Day15Safe implements Runnable {static int ticket = 100;Object obj = new Object();@Overridepublic void run() {while (true) {try {Thread.sleep(1000L);} catch (InterruptedException e) {throw new RuntimeException(e);}method();}}public static synchronized void method() {if (ticket > 0) {System.out.println(Thread.currentThread().getName() + "...买了第" + ticket + "张票");ticket--;
//        }
//    public void method() {
//        synchronized (Day15SafeTest.class) {
//            if (ticket > 0) {
//                System.out.println(Thread.currentThread().getName() + "...买了第" + ticket + "张票");
//                ticket--;
//            }}}
}

两种方法的差距主要在成员变量与方法的static

关于StringBuilder线程不安全与StringBuffer线程安全是因为StringBuffer中放置了安全锁

四、死锁

1、死锁介绍（锁嵌套就可能导致死锁）

指的是两个或者两个以上的线程在执行的过程中由于竞争同步锁而产生的一种阻塞现象;如果没有外力的作用,他们将无法继续执行下去,这种情况称之为死锁

根据上图所示:线程1正在持有锁1,但是线程1必须再拿到锁2,才能继续执行
而线程2正在持有锁2,但是线程2需要再拿到锁1,才能继续执行
此时两个线程处于互相等待的状态,就是死锁,在程序中的死锁将出现在同步代码块的嵌套中

2、死锁的分析

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3、代码实现

定义锁A

public class LockA {public static LockA lockA = new LockA();
}

定义锁B

public class LockB {public static LockB lockB = new LockB();
}

自定义线程

package com.code.day15;public class DieLock implements Runnable {private boolean flag;public DieLock(boolean flag) {this.flag = flag;}@Overridepublic void run() {if (flag) {synchronized (LockA.lockA) {System.out.println("A线程开始执行");synchronized (LockB.lockB) {System.out.println("B线程开始执行");}}} else {synchronized (LockB.lockB) {System.out.println("B线程开始执行");synchronized (LockA.lockA) {System.out.println("A线程开始执行");}}}}
}

测试

package com.code.day15;public class Day15LockTest {public static void main(String[] args) {DieLock dieLock1 = new DieLock( true);DieLock dieLock2 = new DieLock( false);Thread thread1 = new Thread(dieLock1);Thread thread2 = new Thread(dieLock2);thread1.start();thread2.start();}
}

A线程开始执行
B线程开始执行

由此可见以上程序出现了死锁问题
em.out.println(“B线程开始执行”);
}
}
} else {
synchronized (LockB.lockB) {
System.out.println(“B线程开始执行”);
synchronized (LockA.lockA) {
System.out.println(“A线程开始执行”);
}
}
}
}
}


**测试**```java
package com.code.day15;public class Day15LockTest {public static void main(String[] args) {DieLock dieLock1 = new DieLock( true);DieLock dieLock2 = new DieLock( false);Thread thread1 = new Thread(dieLock1);Thread thread2 = new Thread(dieLock2);thread1.start();thread2.start();}
}

A线程开始执行
B线程开始执行

由此可见以上程序出现了死锁问题

http://www.xdnf.cn/news/19932.html

相关文章：

  • 残差网络的介绍
  • 【代码随想录算法训练营——Day2】数组——209.长度最小的子数组、59.螺旋矩阵II、区间和、开发商购买土地
  • “人工智能+”的新范式：应用赋能与风险应对
  • 不会战略、不会融资、不会搭团队？别叫自己 CTO
  • /Users/yourname/Library/Developer/Xcode 文件夹里面各子文件夹作用
  • 【LeetCode热题100道笔记】缺失的第一个正数
  • 【CouponHub项目开发】使用RocketMQ5.x实现延时修改优惠券状态，并通过使用模板方法模式重构消息队列发送功能
  • 3分钟快速了解ToDesk远程控制企业版的技术奥秘！
  • 为什么打印出来的 cJSON type 值和头文件定义的不一样？
  • git还原操作
  • ultralytics/nn/tasks.py源码学习笔记——核心函数parse_model
  • day2today3夏暮客的Python之路
  • 「逆向思维」的胜利：从“挤不上电梯”到“高效学习”的顶级心法
  • 2025年度GEO优化公司市场研究报告：技术驱动下的用户口碑洞察
  • Git的强软硬回退（三）
  • Docmost：面向现代团队的企业级Wiki
  • 鸿蒙：状态管理V2（V2装饰器的学习）
  • 超详细教程：一招一式教你将本地项目上传至GitHub
  • 【系统架构设计（13）】项目管理上：盈亏平衡分析与进度管理
  • SpringBoot 网络流量抓包与分析系统
  • 【RNN-LSTM-GRU】第一篇 序列建模基础：理解数据的“顺序”之力
  • Mac 使用 softhsm
  • 革新光纤锁模技术：《Light: Science Applications》报道纳米腔增强型可饱和吸收器
  • 质量管理里常见的缩写QA、QC、QE都是什么意思？
  • 彻底搞懂面向对象分析（OOA）
  • Linux内存管理章节一：深入浅出Linux内存管理：从物理内存到ARM32的用户与内核空间
  • 逻辑回归基础
  • .NET GcPDF V8.2 新版本：人工智能 PDF 处理
  • Spring Boot 根据配置优雅的决定实现类
  • Meshroom 2025.1.0安装及使用参数模板介绍：二维图片转三维重建