Java基础---多线程
多线程
程序，进程，线程
---程序(program)：是为完成特定任务、用某种语言编写的一组指令的集合,是一段静态的代码。 （程序是静态的）
---进程(process)：是程序的一次执行过程。正在运行的一个程序，进程作为资源分配的单位，在内存中会为每个进程分配不同的内存区域。 （进程是动态的）是一个动的过程 ，进程的生命周期 : 有它自身的产生、存在和消亡的过程
---线程(thread)，进程可进一步细化为线程， 是一个程序内部的一条执行路径。
若一个进程同一时间并行执行多个线程，就是支持多线程的
--单核CPU多核CPU
单核CPU--其实，cpu执行是按照时间片执行的，时间片很短，所以几乎认为多个线程“同时”执行，是个假象
多核CPU时，才是真正意义的一个时间片多线程同时执行-->真正的多线程
--并发和并行：
并行：多个CPU同时执行多个任务
并发：一个CPU“同时”执行多个任务（采用时间片切换）
创建线程的三种方式
我们以前写的程序，也是多线程
第一种：继承Thread类
1）制造线程---
1.继承一个类：Thread；
2.必须是重写Thread类中的run方法,然后线程的任务/逻辑写在run方法中；
3.想要tt子线程真正起作用比如要启动线程-- tt.start();
/*
* 线程类叫：TestThread1，不是说你名字中带线程单词你就具备多线程能力了（争抢资源能力）
* 现在想要具备能力，继承一个类：Thread，具备了争抢资源的能力
*/
public class TestThread1 extends Thread {
/* 一会线程对象就要开始争抢资源了，这个线程要执行的任务到底是啥？这个任务你要放在方法中，但是这个方法不能是随便写的一个方法，必须是重写Thread类中的run方法,然后线程的任务/逻辑写在run方法中 */
@Override
public void run(){
//输出1-10
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
}
public static void main(String[] args) {
//主线程也要输出10个数
for (int i = 0; i <10 ; i++) {
System.out.println("main1-------"+i);
}
//制造其他线程，跟主线程抢资源
TestThread1 tt = new TestThread1(); //具体的线程对象：子线程
// tt.run();调用run方法，想要执行线程中的任务 -->这个run方法不能直接调用，直接调用就会被当做一个普通方法
//想要tt子线程真正起作用比如要启动线程：
tt.start(); //start()是Thread类中的方法
//主线程也要输出10个数
for (int i = 0; i <10 ; i++) {
System.out.println("main2-------"+i);
}
}
程序刚进来---》先把main1的数打印完，激活子线程，子线程和下面的main2抢资源
2）设置读取线程名字
----1.setName,getName方法来进行设置读取：
---2.通过构造器设置 名字：
获取还是通过getName,设置的时候通过有参构造器的参数传到里面
3）案例：买火车票
public class Test1BuyTicketThread extends Thread{
public Test1BuyTicketThread(String name){ //有参构造-主函数中传入参数名字
super(name);
}
static int ticketNum = 10; //多个对象共享10张票
@Override
public void run(){
//每个窗口有100人在抢票
for (int i = 1; i <101 ; i++) {
if(ticketNum > 0){
System.out.println("我在"+this.getName()+"买到了长治到北京的第"+ticketNum-- +"张车票");
}
}
}
}
public class Test1BuyTicketTest {
public static void main(String[] args) {
//三个窗口抢票
Test1BuyTicketThread t1 = new Test1BuyTicketThread("窗口一");
t1.start();
Test1BuyTicketThread t2 = new Test1BuyTicketThread("窗口二");
t2.start();
Test1BuyTicketThread t3 = new Test1BuyTicketThread("窗口三");
t3.start();
}
}
第二种：实现Runnable接口
必须是重写run方法,然后线程的任务/逻辑写在run方法中
public class Test2Thread2 implements Runnable{
@Override
public void run(){
for (int i = 0; i <10 ; i++) {
System.out.println(Thread.currentThread().getName()+"----"+i);
}
}
}
public static void main(String[] args) {
Test2Thread2 tt = new Test2Thread2();
Thread t = new Thread(tt,"子线程"); //通过这样把tt和t联系起来，因为start是Thread 中的方法
t.start();
//主线程
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"----"+i);
}
}
--案例：买火车票
public class Test2BuyTicketThread implements Runnable {
int ticketNum = 10;
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (ticketNum > 0) {
System.out.println("我在"+Thread.currentThread().getName()+"买到了从长治到北京的第"+ticketNum--+"张票");
}
}
}
}
public static void main(String[] args) {
//定义一个线程对象
Test2BuyTicketThread tt = new Test2BuyTicketThread();
//在窗口一买票
Thread t1 = new Thread(tt,"窗口一");
t1.start();
//在窗口二买票
Thread t2 = new Thread(tt,"窗口二");
t2.start();
//在窗口三买票
Thread t3 = new Thread(tt,"窗口三");
t3.start();
}
实际开发中，方式1继承Thread类 还是 方式2实现Runnable接口这种方式多呢？
--》方式2
（1）方式1的话有 Java单继承的局限性，因为继承了Thread类，就不能再继承其它的类了
（2）方式2的共享资源的能力也会强一些，不需要非得加个static来修饰
Thread类 Runnable接口 有联系吗？
第三种：实现Callable接口：
实现Callable接口：
好处：（1）有返回值 （2）能抛出异常
缺点：线程创建比较麻烦
实现Callable接口，可以不带泛型，如果不带泛型，那么call方式的返回值就是Object类型
如果带泛型，那么call的返回值就是泛型对应的类型
public class Test3 implements Callable {
@Override
public Object call() throws Exception { //有返回值，可以抛出异常
return new Random().nextInt(10); //返回10以内的随机数
}
}
class Randomtext3{
public static void main(String[] args) throws ExecutionException, InterruptedException {
//定义一个线程对象，通过媒介FutureTask来与Thread联系起来，从而可以start
Test3 t = new Test3();
FutureTask ft = new FutureTask(t);
Thread td = new Thread(ft); //Thread里的参数必须是Runnable的实现类
td.start();
//获取线程的到的返回值
Object o = ft.get();
System.out.println(o);
}
}
线程的生命周期
1）线程生命周期：线程开始---->消亡
2）线程经历阶段：
线程常见方法
基础：
（1）start() : 启动当前线程，表面上调用start方法，实际在调用线程里面的run方法
（2）run() : 线程类 继承 Thread类 或者 实现Runnable接口的时候，都要重新实现这个run方法，run方法里面是线程要执行的内容
（3）currentThread :Thread类中一个静态方法：获取当前正在执行的线程
（4）setName 设置线程名字
（5）getName 读取线程名字
设置优先级:
【1】同优先级别的线程，采取的策略就是先到先服务，使用时间片策略
【2】如果优先级别高，被CPU调度的概率就高
【3】级别：1-10 默认的级别为5
public class Test4Thread extends Thread{
@Override
public void run(){
for (int i = 0; i <10 ; i++) {
System.out.println(i);
}
}
}
class Test4Thread1 extends Thread{
@Override
public void run(){
for (int i = 20; i < 30; i++) {
System.out.println(i);
}
}
}
class Test{
public static void main(String[] args) {
//创建两个字线程，争抢资源
Test4Thread th = new Test4Thread();
th.setPriority(10); //优先级别高
th.start();
Test4Thread1 th1 = new Test4Thread1();
th1.setPriority(3); //优先级别低
th1.start();
}
}
Join:
join方法：当一个线程调用了join方法，这个线程就会先被执行，它执行结束以后才可以去执行其余的线程。
注意：必须先 start，再 join才有效。
public class Test5Thread extends Thread{
@Override
public void run(){
for (int i = 0; i <10 ; i++) {
System.out.println(Thread.currentThread().getName()+"------"+i);
}
}
}
class Test5{
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i <10 ; i++) {
if (i == 6){
//创建线程---i=6进入子线程，把子线程全都结束，才继续执行主线程
Test5Thread tt = new Test5Thread();
tt.start();
tt.join();
}
System.out.println(Thread.currentThread().getName()+"------"+i);
}
}
}
sleep:
【1】sleep : 人为的制造阻塞事件
public static void main(String[] args) throws InterruptedException {
//人为加一个阻塞，让他3秒后输出
Thread.sleep(3000); //以毫秒为单位
System.out.println("diddidiididiidid");
}
【2】案例：完成秒表功能：
//完成秒表功能
public static void main(String[] args) throws InterruptedException {
DateFormat df = new SimpleDateFormat("HH:mm:ss"); //规定格式
while(true){
Date d = new Date(); //获取当前时间
System.out.println(df.format(d));//按照上面定义的格式将Date类型转为指定格式的字符串：
Thread.sleep(1000); //隔一秒钟再输出
}}
setDaemon:
【1】设置伴随线程
将子线程设置为主线程的伴随线程，主线程停止的时候，子线程也不要继续执行了
案例：皇上 --》驾崩 ---》妃子陪葬（垂死挣扎也正常）
public class Test7Thread extends Thread{
public Test7Thread(String name){
super(name);
}
@Override
public void run(){
for (int i = 0; i <100 ; i++) {
System.out.println(this.getName()+"======="+i);
} }}
class Test7{
public static void main(String[] args) {
//创建子线程并设置伴随线程
Test7Thread t = new Test7Thread("子线程"); //通过有参构造给子线程取名
t.setDaemon(true); //先设置伴随，再启动线程
t.start();
//主线程也输出10个数
for (int i = 0; i <10 ; i++) {
System.out.println(Thread.currentThread().getName()+"-----"+i);
}
}
}
stop:
public class Demo {
public static void main(String[] args) {
for (int i = 1; i <= 100 ; i++) {
if(i == 6){
Thread.currentThread().stop(); //i=6就停止-过期方法，不建议使用
}
System.out.println(i);
}
}}
线程安全问题
上面的代码出现问题：出现了 重票，错票，---》 线程安全引起的问题
原因：多个线程，在争抢资源的过程中，导致共享的资源出现问题。一个线程还没执行完，另一个线程就参与进来了，开始争抢。
解决：在我的程序中，加入“锁” --》加同步 --》同步监视器
同步代码块
---同步监视器总结：
总结1：认识同步监视器（锁子） ----- synchronized(同步监视器){ }
1)必须是引用数据类型，不能是基本数据类型
2)也可以创建一个专门的同步监视器，没有任何业务含义
3)一般使用共享资源做同步监视器即可
4)在同步代码块中不能改变同步监视器对象的引用
5)尽量不要String和包装类Integer做同步监视器
6)建议使用final修饰同步监视器
总结2：同步代码块的执行过程
1)第一个线程来到同步代码块，发现同步监视器open状态，需要close,然后执行其中的代码
2)第一个线程执行过程中，发生了线程切换（阻塞 就绪），第一个线程失去了cpu，但是没有开锁open
3)第二个线程获取了cpu，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态
4)第一个线程再次获取CPU,接着执行后续的代码；同步代码块执行完毕，释放锁open
5)第二个线程也再次获取cpu，来到了同步代码块，发现同步监视器open状态，拿到锁并且上锁，由阻塞状态进入就绪状态，再进入运行状态，重复第一个线程的处理过程（加锁）
强调：同步代码块中能发生CPU的切换吗？能！！！ 但是后续的被执行的线程也无法执行同步代码块（因为锁仍旧close）
总结3：其他
1)多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块 。但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块
同步方法
把可能出问题的代码提出来搞成一个方法，锁住
【2】总结：
总结1：
多线程在争抢资源，就要实现线程的同步（就要进行加锁，并且这个锁必须是共享的，必须是唯一的。锁一般都是引用数据类型的。
目的：解决了线程安全问题。
总结2：关于同步方法
- 不要将run()定义为同步方法
- 非静态同步方法的同步监视器是this；
静态同步方法的同步监视器是：类名.class //字节码信息对象
- 同步代码块的效率要高于同步方法
原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却是方法的内部
- 同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；
同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块
Lock锁
【1】Lock锁引入：
JDK1.5后新增新一代的线程同步方式:Lock锁
与采用synchronized相比，lock可提供多种锁方案，更灵活
synchronized是Java中的关键字，这个关键字的识别是靠JVM来识别完成的呀。是虚拟机级别的。
但是Lock锁是API级别的，提供了相应的接口和对应的实现类，这个方式更灵活，表现出来的性能优于之前的方式。
【2】代码演示：
【3】 Lock和synchronized的区别
1.Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁
2.Lock只有代码块锁，synchronized有代码块锁和方法锁
3.使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类
【4】优先使用顺序：
Lock----同步代码块（已经进入了方法体，分配了相应资源）----同步方法（在方法体之外）
线程同步优缺点
【1】对比：
线程安全，（加了锁）效率低
线程不安全，效率高
【2】可能造成死锁：
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
【3】代码演示：
public class TestDeadLock implements Runnable {
public int flag = 1;
static Object o1 = new Object(),o2 = new Object(); //创建一个专门的同步监视器,必须用static修饰，唯一的
public void run(){
System.out.println("flag=" + flag);
// 当flag==1锁住o1
if (flag == 1) {
synchronized (o1) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
// 只要锁住o2就完成
synchronized (o2) {
System.out.println("2");
}
}
}
// 如果flag==0锁住o2
if (flag == 0) {
synchronized (o2) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
// 只要锁住o1就完成
synchronized (o1) {
System.out.println("3");
}
}
}
}
public static void main(String[] args) {
// 实例2个线程类
TestDeadLock td1 = new TestDeadLock();
TestDeadLock td2 = new TestDeadLock();
td1.flag = 1;
td2.flag = 0;
// 开启2个线程
Thread t1 = new Thread(td1);
Thread t2 = new Thread(td2);
t1.start();
t2.start();
}
}
【4】解决方法： 减少同步资源的定义，避免嵌套同步
线程通信问题
代码：
1.商品：属性：品牌 ，名字
2.线程1：生产者
3.线程2：消费者
生产者消费者分解一
代码展示：
结果：
出现问题：
1.生产者和消费者没有交替输出
2.打印数据错乱
哈尔滨 - null
费列罗啤酒
哈尔滨巧克力
because ----没有加同步
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？