Java多线程2

最新推荐文章于 2024-10-15 13:49:16 发布
最新推荐文章于 2024-10-15 13:49:16 发布
阅读量492 收藏
点赞数 1
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69855013/article/details/126667211
版权
本文详细介绍了Java线程的生命周期，包括新建、就绪、运行、阻塞和死亡状态，并通过实例解析了线程API的使用，如线程状态获取、休眠、名字、优先级、礼让和join()方法。此外，还讨论了线程停止的推荐做法、线程同步的实现及优缺点，以及线程阻塞、死锁的概念和避免策略。
摘要由CSDN通过智能技术生成

Java多线程


前言：
在 Java多线程前半部分文章里，我们大致学习了多线程的定义以及如何用java实现多线程。因此我们继续来学习多线程。

一、线程的生命周期

首先，我们在编写Java代码程序时，要先了解程序是什么样子的过程，才能用JAVA语言描述出来，而线程也是这样的，我们要了解线程怎样开始，到怎样结束才好来写代码。其中对于线程来说，它有这它自己独特的生命周期。

线程生命周期图：
在这里插入图片描述

  1. 新建状态(通过构造): 线程new出来，但是还没有调用start()
  2. 就绪状态(通过start()方法)：线程调用start()，没有抢占到CPU资源
  3. 运行状态(通过资源调度，获取资源)：线程已经抢占到CPU资源，执行run（）方法
  4. 阻塞状态：调用sleep（），没有获取到锁，wait（）…线程挂起（暂停）
  5. 死亡状态：正常死亡（run方法结束），非正常死亡（stop（），destory（）都已过时）

**例子：**跑步
（1）有sleep（）阻塞：

/**
*有sleep（）阻塞
 * 跑步类
 */
public class Run implements Runnable{
    
    private static String WIN;//赢的人
    @Override
    public void run() {
        int a = (int) (Math.random() * 3 + 1);//1<=a<3
        for (int i = 1; i <= 5; i++) {
            try {
                Thread.sleep(a * 1000);
                System.out.println(Thread.currentThread().getName() + "  跑完了第" + i + "圈  用时" + a + "秒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i == 5) {
                System.out.println(Thread.currentThread().getName() + "跑完了");
            }
        }
    }
}

（2）无sleep（）阻塞：

/**
*无sleep（）阻塞
 * 跑步类
 */
public class Run implements Runnable{
    
    private static String WIN;//赢的人
    @Override
    public void run() {
        int a = (int) (Math.random() * 3 + 1);//1<=a<3
        for (int i = 1; i <= 5; i++) {
            // Thread.sleep(a * 1000);
            System.out.println(Thread.currentThread().getName() + "  跑完了第" + i + "圈  用时" + a + "秒");
            if (i == 5) {
                System.out.println(Thread.currentThread().getName() + "跑完了");
            }
        }
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        Run run=new Run();
        Thread t1=new Thread(run,"张三");
        Thread t2=new Thread(run,"李四");
        Thread t3=new Thread(run,"王五");
        t1.start();
        t2.start();
        t3.start();
    }
}

结果（1）：

张三  跑完了第1圈  用时1秒
王五  跑完了第1圈  用时2秒
张三  跑完了第2圈  用时1秒
李四  跑完了第1圈  用时3秒
张三  跑完了第3圈  用时1秒
王五  跑完了第2圈  用时2秒
张三  跑完了第4圈  用时1秒
张三  跑完了第5圈  用时1秒
张三跑完了
李四  跑完了第2圈  用时3秒
王五  跑完了第3圈  用时2秒
王五  跑完了第4圈  用时2秒
李四  跑完了第3圈  用时3秒
王五  跑完了第5圈  用时2秒
王五跑完了
李四  跑完了第4圈  用时3秒
李四  跑完了第5圈  用时3秒
李四跑完了

结果（2）：

张三  跑完了第1圈  用时1秒
张三  跑完了第2圈  用时1秒
张三  跑完了第3圈  用时1秒
张三  跑完了第4圈  用时1秒
张三  跑完了第5圈  用时1秒
张三跑完了
李四  跑完了第1圈  用时1秒
李四  跑完了第2圈  用时1秒
李四  跑完了第3圈  用时1秒
李四  跑完了第4圈  用时1秒
李四  跑完了第5圈  用时1秒
李四跑完了
王五  跑完了第1圈  用时2秒
王五  跑完了第2圈  用时2秒
王五  跑完了第3圈  用时2秒
王五  跑完了第4圈  用时2秒
王五  跑完了第5圈  用时2秒
王五跑完了

当线程1张三在遇到sleep（）时，由运行状态改为阻塞状态，当sleep（）的时间到了之后，线程则变为就绪状态，这时线程1张三，线程2李四，线程3王五三者就会重新抢占CPU的资源，谁抢占得就谁先运行，就会有结果（1）。
如果一个线程没有遇到sleep（）或join（）或IO等阻塞条件时，就会一直进行下去，直至线程的结束，就像结果（2）一样。

二、线程的API

2.1 获取线程状态

Thread.State getState();

在这里插入图片描述

测试：

public class Test {
    public static void main(String[] args) {
        Run run=new Run();
        Thread t1=new Thread(run,"张三");
        Thread t2=new Thread(run,"李四");;
        t1.start();
        System.out.println(t1.getState());
        t2.start();
    }
}

结果：

RUNNABLE   //执行状态
张三  跑完了第1圈  用时1秒
张三  跑完了第2圈  用时1秒
张三  跑完了第3圈  用时1秒
李四  跑完了第1圈  用时3秒
张三  跑完了第4圈  用时1秒
张三  跑完了第5圈  用时1秒
张三跑完了
李四  跑完了第2圈  用时3秒
李四  跑完了第3圈  用时3秒
李四  跑完了第4圈  用时3秒
李四  跑完了第5圈  用时3秒
李四跑完

2.2 线程休眠

sleep(毫秒数),让线程休眠,时间到，自动唤醒并继续执行，它会释放cpu资源，但是不释放锁 。例子看上面

2.3 获取线程名字

Thread.currentThread().getName;   //表示获取当前正在执行的线程对象的名字

2.4 线程的优先级

线程优先极高的与线程优先级低的线程抢占资源，不一定是优先级高的一定能抢占资源，只是优先级高的抢占到资源的概率比较大。

默认优先级是五，线程优先级1-10

2.5 礼让：yield()

某个线程调用yield（），释放cpu资源，与其他线程抢占CPU资源，谁抢到谁先执行

例子：

public class MyThread2 extends Thread {
    public MyThread2(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"正在执行...");
        System.out.println(Thread.currentThread().getName()+"执行结束...");
    }

    public static void main(String[] args) {
        MyThread2 t1 = new MyThread2("A");
        MyThread2 t2 = new MyThread2("B");
        t1.start();
        t2.start();
        t1.yield(); //礼让


    }
}

2.6 join()：类似插队

先准备一个A线程，在执行A线程过程中准备B线程，并让B线程就绪，然后A线程执行到一半之后,让B线程调用join方法，此时A线程阻塞，B
线程启动执行，当B线程执行完毕后，A线程再继续执行

例子：

public class MyThread3 extends  Thread{
    public MyThread3(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println(this.getName()+">>"+i);
            if(i == 50){
                MyThread4 thread4 = new MyThread4("地主家的傻儿子");
                thread4.start();
                //插队
                try {
                    thread4.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        MyThread3 thread3 = new MyThread3("普通人");
        thread3.start();
    }
}

三、线程停止

让线程停止有两种方法：

1.调用线程stop()，已过时

2.推荐方式：设置一个标志符flag，控制标志标志符的值

例子(使用标志符)：

public class MyRun extends Thread {
    private boolean flag = true;
    public MyRun(String name) {
        super(name);
    }

    @Override
    public void run() {
        int i = 0;
        while(flag){
            i++;
            System.out.println(this.getName()+">>>"+i);
        }
    }
    public void changeFlag(boolean  flag){
        this.flag = flag;
    }

    public static void main(String[] args) throws InterruptedException {
        MyRun t5 = new MyRun("t5");
        t5.start();
        //那个线程执行这行代码,就是那个线程睡眠
        Thread.sleep(1000);
        t5.changeFlag(false);
    }
}

四、线程同步

多线程并发访问一个共享资源，并且修改资源，可能出现以下情况：

1.同步方法

在方法上添加上一个Synchronied修饰符，在对象、方法上加锁

非静态同步方法：

​ 锁加在this对象

静态同步方法：

​ 锁加在类. class（对象）上

锁的释放：当把同步方法执行之后，马上释放

2.同步代码块

public 返回值类型 方法名（）{
	Synchronied (对象){
	   //锁住的代码
	}
}

同步缺点:

1.效率低,排队

2.容易造成死锁

例子（多个窗口出售车票）：
1、同步方法

public class SellTicketTask implements Runnable{
private int count=10;//票数
private boolean flag=true;//没有卖完

@Override
public void run() {
   //循环购票
   while (flag){
       sellTicket();
   }
}

//买票方法
//分析：买票原子性操作，给买票加锁
//把买票方法设置成同步方法
public synchronized void sellTicket(){
   if (count>0){//有票

       try {
           //线程睡眠，模拟出票所需的时间   让别的线程得到CPU的资源
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       //出票
       System.out.println(Thread.currentThread().getName()+"：出售第"+count+"张票");
       count--;

   }else {//没有票
       flag=false;
   }
}
}

2、同步代码块

//买票方法
//分析：买票原子性操作，给买票加锁
//把买票方法设置成同步方法
public synchronized void sellTicket(){
   System.out.println("正在出票...");
   synchronized (this){
       if (count>0){//有票

           try {
               //线程睡眠，模拟出票所需的时间   让别的线程得到CPU的资源
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           //出票
           System.out.println(Thread.currentThread().getName()+"：出售第"+count+"张票");
           count--;

       }else {//没有票
           flag=false;
       }
   }
}

五、线程阻塞

1.同步阻塞

2.Thread.sleep()的方法：时间到自动醒,释放cpu资源,不释放锁资源,join() 阻塞

3.yield() 礼让

4.wait()等待 位于Object类 的方法,一定要等待唤醒notify() /notifyAll().释放cpu

资源同时也释放锁,一般在线程通讯中

六、线程死锁

死锁产生的必要条件:

​ 1> 互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

​ 2> 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

​ 3> 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占用。

​ 4> 循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路

​ 在我们的项目中，我们不希望看到死锁的发生，为了避免，以上四个条件，破坏其中任意一个，死锁就结束了

​ 注意：过多的同步会导致死锁

例子（模拟死锁）:

/**
* 死锁
*/
public class Demo implements Runnable{
//对象死锁
public Object objA=new Object();
public Object objB=new Object();
private static boolean flag=true;//标签 true获取锁顺序: objA-objB false获取锁顺序: objB-objA


//修改flag值
/*    public void sellFlag(Boolean flag){
   this.flag=flag;
}*/
public void sellFlag(){
   flag=false;
}

public void sell(){
   if(flag==true){
       //请求objA死锁
       synchronized (objA){
           System.out.println(Thread.currentThread().getName()+"获得死锁objA");

       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       //请求objB死锁
       synchronized (objB) {
           System.out.println(Thread.currentThread().getName() + "获得死锁objB");
       }
       }//从synchronized (objA)到结束，锁住整个
   }else{
       //请求objB死锁
       synchronized (objB){
           System.out.println(Thread.currentThread().getName()+"获得死锁objB");

       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       //请求objA死锁
       synchronized (objA){
           System.out.println(Thread.currentThread().getName()+"获得死锁objA");
       }
       }
   }
}

@Override
public void run() {
   sell();
}
}

测试：

public class Test {
public static void main(String[] args) {
   Demo demo=new Demo();
   new Thread(demo,"t1").start();
   try {
       Thread.sleep(50);
   } catch (InterruptedException e) {
       e.printStackTrace();
   }
   demo.sellFlag();
   new Thread(demo,"t2").start();
}
}
小温豌豆
关注
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
java多线程2
05-03
Java多线程是Java编程中的一个核心概念，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程主要通过两种方式实现：继承Thread类和实现Runnable接口。 1. 继承Thread类：创建一个新的...
Java多线程结构_Java多线程结构_
09-30
Java多线程结构是Java编程中的重要组成部分，它允许程序同时执行多个任务，提升系统效率。在Java中，实现多线程主要有两种方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当自定义类继承Thread类时，...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1465
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Java分布式锁
juanmiao的专栏
10-12 660
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 892
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 676
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Backend - Java 基础
是萝卜干呀的博客
10-11 833
知识量决定了未来能走多远
JavaSE——认识异常
wx2023_10_15的博客
10-12 955
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
java工具类判断一个点是否在多边形内
weixin_47315082的博客
10-15 147
最近在做的项目，需要画一个多边形范围，并且判断当前定位是否在这个范围内，进出需要提醒，因此写了一个工具类判断一个点是否在多边形内，记录一下。
springboot 用request.setAttribute 传值到控制层
qq56477643的博客
10-09 617
【代码】springboot 用request.setAttribute 传值到控制层。
【网络编程】掌握Java网络编程：深入理解Socket通信与实战技巧
Dylaniou的博客
10-11 1046
Java的网络Socket编程为开发者提供了强大的工具来构建网络通信应用，从简单的客户端-服务器模型到复杂的分布式系统。Java的网络Socket编程为开发者提供了强大的工具来构建网络通信应用，从简单的客户端-服务器模型到复杂的分布式系统。希望本文能帮助您掌握Java网络编程的核心技术，并在实际项目中灵活运用。如果您有任何疑问或想要分享经验，请在评论区留下您宝贵的意见！🚀🌐🔌。
Unsafe 详解
qq_73210658的博客
10-10 2480
学习JUC的过程中发现有一个类很神奇，今天我们就来一起学习一下Unsafe类。
JavaScript前端开发技术
Chujun123528的博客
10-12 1006
JavaScript前端开发是一个充满挑战和机遇的领域。随着技术的不断进步和用户需求的变化，前端开发者需要不断学习新知识、掌握新技能，以应对日益复杂和多样化的开发需求。同时，注重性能优化和安全实践也是前端开发不可或缺的一部分。通过不断探索和创新，我们可以为用户创造更加优质、高效和安全的Web体验。在JavaScript前端开发的学习过程中，建议从基础语法入手，逐步掌握DOM操作、事件处理、Ajax通信等核心技能。同时，关注最新的前端框架和库的发展动态，尝试将它们应用到实际项目中。
Java基础-基础知识体系小结 Q/A
令狐_JackieHao的博客
10-10 1306
Java基础知识的一些梳理
springboot官方文档回顾复习
最新发布
qq_39833005的博客
10-15 785
springboot官方文档
Linux线程（十二）线程互斥锁-自旋锁与读写锁详解
Dola的博客
10-10 938
自旋锁与互斥锁很相似，从本质上说也是一把锁，在访问共享资源之前对自旋锁进行上锁，在访问完成后释放自旋锁（解锁）；事实上，从实现方式上来说，互斥锁是基于自旋锁来实现的，所以自旋锁相较于互斥锁更加底层。如果在获取自旋锁时，自旋锁处于未锁定状态，那么将立即获得锁（对自旋锁上锁）；如果在获取自旋锁时，自旋锁已经处于锁定状态了，那么获取锁操作将会在原地“自旋”，直到该自旋锁的持有者释放了锁。由此介绍可知，自旋锁与互斥锁相似，但是互斥锁在无法获取到锁时会让线程陷入阻塞等待状态；
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小温豌豆

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值