多线程详解

已于 2022-11-23 17:03:14 修改
阅读量73 收藏
点赞数
分类专栏： 笔记 文章标签： java 开发语言
于 2022-11-19 21:15:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53415378/article/details/127938940
版权

文章目录

01.线程基本概念

程序、进程（Process）、线程(Thread)概念

1.程序:是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
2.进程:程序的一次执行过程，是一个动态的概念。是系统资源分配的单位。
3.线程:一个进程可以包含若干个线程，一个进程中至少有一个线程，否则进程没有存在的意义。线程是CPU调度和执行的单位。

02.线程创建方式

1.1 继承Thread类（重点）

  • （1）自定义线程类继承Thread类
  • （2）重写run()方法
  • （3）创建线程对象，调用start()方法启动线程
public class Threadone extends Thread{//1.继承Thread类
    @Override
    public void run() {//2.重写run()方法
        //run()方法线程体
        for (int i = 1; i <=10; i++) {
            System.out.println("多线程学习！");
        }
    }

    public static void main(String[] args) {//主线程，main()线程
        //创建一个线程对象
        Threadone thread1 = new Threadone();//3.创建线程对象，调用start()方法启动线程
        //线程对象调用start()方法开启线程
        thread1.start();
        
        for (int i = 1; i <=1000; i++) {
            System.out.println("主线程内容");
        }
    }
}

结果截图（两个线程交替使用CPU）
在这里插入图片描述

1.2 实现Runable接口（重点）

  • （1）自定义类实现Runnable接口
  • （2）实现run()方法
  • （3）创建线程对象，调用start()方法启动线程
public class Threadtwo implements Runnable{
    @Override
    public void run() {//重写run()方法
        for (int i = 0; i < 10; i++) {
            System.out.println("重写run()方法");
        }
    }

    public static void main(String[] args) {
        //创建Runnable接口的实现类对象、
        Threadtwo threadtwo = new Threadtwo();

        //创建线程对象，通过线程对象来开启线程(代理)
        Thread thread = new Thread(threadtwo);
        thread.start();

        for (int i = 1; i <=1000; i++) {
            System.out.println("主线程内容!");
        }
    }
}

结果截图（两个线程交替使用CPU）
在这里插入图片描述

1.3 实现Callable接口（自行了解）

1.4 小总结

继承Thread类:
1.子类继承Thread类具备多线程能力
2.启动线程:子类对象.start()
3.不建议使用:避免OOP单继承局限性

实现Runnable接口:
1.实现接口Runnable具有多线程能力
2.启动线程:传入目标对象+Thread.start()
3.推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用

03.多线程模拟龟兔赛跑

  1. 首先来个赛道距离，然后离终点距离越来越近
  2. 判断比赛是否结束
  3. 打印出胜利者
  4. 龟兔赛跑开始
  5. 故事中乌龟赢的比赛，要模拟兔子睡觉
  6. 最终，乌龟赢的比赛
package ThreadLearn;

public class Race implements Runnable{
    //胜利者
    private String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //模拟兔子睡觉,
            if(Thread.currentThread().getName().equals("兔子")&&i%10==0){//获取线程名称
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"向前跑了:"+i+"步");
        }
    }
    private boolean gameOver(int steps){
        //判断是否完成比赛
        if(winner!=null){//若以及存在胜利者
            return true;
        }else {
            if (steps>=100){
                winner = Thread.currentThread().getName();
                System.out.println("胜利者是---"+winner);
                return true;
            }
            return false;
        }
    }

    public static void main(String[] args) {
        Race race = new Race();

        Thread runner1 = new Thread(race,"小兔子");
        Thread runner2 = new Thread(race,"小乌龟");

        runner1.start();
        runner2.start();
    }
}

结果截图
在这里插入图片描述

04.Lambda表达式

1.为避免内部类过多
  (params)->expression[表达式]
  (params)->statement[语句]
  (params)->{statement}
  a->System.out.println("Welcome to Java");

2.函数式接口:只包含唯一一个抽象方法的接口

public class TestLamda1 {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lamda() {
            System.out.println("I don't like Lambda");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like1();
        like.lamda();
        like = new Like2();
        like.lamda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lamda() {
                System.out.println("I don't like Lambda，too");
            }
        }

        like = new Like3();
        like.lamda();

        //5.匿名内部类,设有类的名称，必须借助类的接口或者父类
        like = new ILike(){
            @Override
            public void lamda() {
                System.out.println("I don't like Lambda，too much");
            }
        };
        like.lamda();

        //6.用Lambda简化(由匿名内部类简化)
        like = ()->{System.out.println("Studying Lambda，now");};
        like.lamda();
    }
}

//1.定义一个函数式接口(即：一个方法只包含一个抽象方法)
interface ILike{
    void lamda();
}

//2.实现类
class Like1 implements ILike{
    @Override
    public void lamda() {
        System.out.println("I like Lambda");
    }
}

结果截图
在这里插入图片描述

05.线程状态

状态简介1:
在这里插入图片描述
状态简介2:在这里插入图片描述

线程方法

方法说明
setPriority(int newPriority)更改线程的优先级
static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程体休眠
void join()等待线程终止
static void yield()暂停当前正在执行的线程对象，并执行其他线程
void interrupt()中断线程(最好别用)
boolean isAlive()测试线程是否处于活动状态

5.1 线程停止_stop

//测试stop类
//1.建议线程正常停止----利用次数，不建议死循环
//2.建议使用标志位----设置一个标志位
//3.不要使用stop和destory等过时方法

public class TestStop implements Runnable{
    //1.设置一个标志位
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while(flag){
            System.out.println("开启线程Run--***--Thread "+i++);
        }
    }
    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop test1 = new TestStop();
        Thread thread1 = new Thread(test1);
        thread1.start();

        //主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程mian执行"+i+"次");
            if(i==900){
                //调用stop方法切换标志，让线程停止
                test1.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

5.2 线程休眠_sleep

1.sleep(毫秒)指定当前线程阻塞的毫秒数
2.sleep存在异常InteruptedException
3.sleep时间到达后线程进入就绪状态
4.sleep可以模拟网络延时
5.每个对象都有一个锁，sleep不会释放锁

//测试sleep
//模拟网络延时
public class TestSleep implements Runnable{
    //票数
    private int ticketNums = 10;
    @Override
    public void run() {
        while (true){
            if(ticketNums<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"买了第"+ticketNums--+"张票");
        }
    }

    public static void main(String[] args) {
        TestSleep ticket = new TestSleep();
        new Thread(ticket,"景天").start();
        new Thread(ticket,"雪见").start();
        new Thread(ticket,"龙葵").start();

    }
}
//有个问题:同张票被两个人（线程）买了

sleep模拟倒计时

import java.text.SimpleDateFormat;
import java.util.Date;
//模拟倒计时
public class TestSleep2 {
    public static void main(String[] args) {
        //获取当前系统时间
        Date startTime = new Date(System.currentTimeMillis());
        while (true){
                countdown();
        }
  }
    //模拟倒计时
    public static void countdown(){
        int num = 10;
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(num--);
                if(num<=0){
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5.3 线程礼让_yield

1.线程礼让，让当前正在执行的线程暂停，但不阻塞(即一同排队等待CPU)
2.让线程从运行状态转为就绪状态
3.让CPU重新调度,礼让不一定成功,看CPU心情    O(∩_∩)O

public class TestYield {
    public static void main(String[] args) {
        Yield yield = new Yield();
        new Thread(yield,"线程1").start();
        new Thread(yield,"线程2").start();
    }
}
class Yield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//线程礼让
        System.out.println(Thread.currentThread().getName()+"线程执行结束");
    }
}

礼让成功
在这里插入图片描述礼让失败
在这里插入图片描述

5.4 线程强制执行_join

1.Join合并线程,待此线程执行完后,在执行其他线程,其他线程阻塞
2.可以想象为插队

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("VIP优先级高优先处理 "+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动我们的线程
        TestJoin test = new TestJoin();
        Thread thread = new Thread(test);
        thread.start();

        //主线程
        for (int i = 0; i < 100; i++) {
            if(i==20) {
                thread.join();
            }
            System.out.println("主线程"+i);
        }
    }
}

在 i==20时，VIP插队
在这里插入图片描述

06.观测线程状态

线程状态:
1.NEW 尚未启动的线程处于此状态
2.RUNNABLE 在JAVA虚拟机中执行的线程处于此状态
3.BLOCKED 被阻塞等待监视锁定的线程处于此状态
4.WAITING 正在等待另一个线程执行特定动作线程处于此状态
5.TIME_WAITING 正在等待另一个线程执行特定动作达到指定等待时间的线程处于此状态
6.TERMINATED 已退出的线程处于此状态

public class TestState extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("*******");
    }
    public static void main(String[] args) {
        Thread thread = new Thread();
        //观察状态
        Thread.State state = thread.getState();
        System.out.println("线程启动前:"+state);
        //线程启动后
        thread.start();
        state = thread.getState();
        System.out.println("线程启动后:"+state);
    }
}

截图显示
在这里插入图片描述

07.线程优先级

1.Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器
  按照优先级决定应该调度哪个线程来执行。
2.线程的优先级用数字表示,范围由1~10，优先级由低到高
     Thread.MIN_PRIORITY = 1;
     Thread.MAX_PRIORITY = 10;
     Thread.NORM_PRIORITY = 5;
3.使用以下方式改变或获取优先级
     getPriority();
     setPriority(int xxx);

public class TestPriority {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"线程的优先级为: "+Thread.currentThread().getPriority());
        IPriority priority = new IPriority();
        Thread t0 = new Thread(priority);
        Thread t1 = new Thread(priority);
        Thread t2 = new Thread(priority);
        Thread t3 = new Thread(priority);
        //先设置优先级,再启动线程
        t0.start();
        
        t1.setPriority(1);
        t1.start();

        t2.setPriority(4);
        t2.start();

        t3.setPriority(Thread.MAX_PRIORITY);
        t3.start();
    }
}
class IPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程的优先级为: "+Thread.currentThread().getPriority());
    }
}

结果截图
在这里插入图片描述

08.守护线程

1.线程分为用户线程和守护线程
2.虚拟机必须确保用户线程执行完毕
3.虚拟机不用等待守护线程执行完毕

package ThreadLearn.ThreadState;
/*
1.线程分为用户线程和守护线程
2.虚拟机必须确保用户线程执行完毕
3.虚拟机不用等待守护线程执行完毕

*/
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        Human human = new Human();

        Thread thread = new Thread(god);//默认false表示用户线程，正常线程都是用户线程
        thread.setDaemon(true);
        thread.start();//上帝守护线程启动

        new Thread(human).start();//用户线程
    }
}
//上帝
class God implements Runnable{
    private boolean flag = true;
    @Override
    public void run() {
        while(true) {
            System.out.println("上帝守护人类!!!");
        }
    }
}
//人类
class Human implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("人类开开心心的活着!!!");
        }
        System.out.println("再见！================================地球");
    }
}

守护线程始终结束在用户线程之后
在这里插入图片描述在这里插入图片描述

09. 线程同步

多个线程操作同一个资源
并发:同一个对象被多个线程同时操作
每一个对象都有一个锁

处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候就需要线程同步。
线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,
等待前面线程使用完毕,下一个线程再使用.

锁机制 synchronized : 当一个线程获得对象的排他锁，独占资源，其他线程必须等待使用后释放解锁即可。当同时也存在以下问题:

学习视频连接:狂神多线程详解

西利亚•海因里希
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程详解及示例
07-20
在多线程环境下，死锁是指两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。活锁则是指线程不断重试获取资源，但由于其他线程持有资源不释放，导致线程陷入无限循环的状态。避免死锁和活锁的关键在于...
Python多线程详解
01-27
线程有5种状态，状态转换的过程如下图所示：多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。考虑这样一种情况：一个列表里所有元素都是0，线程...
C#高级--多线程详解
李宥的博客
10-03 4万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
python多线程详解（超详细）
热门推荐
世俗的眼光
03-30 21万+
python中的多线程是一个非常重要的知识点，今天为大家对多线程进行详细的说明，代码中的注释有多线程的知识点还有测试用的实例。 import threading from threading import Lock,Thread import time,os ''' python多线程详解 什么是线程？ ...
Java多线程详解
坏蛋阿土的博客
11-06 6599
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
一文详解C++多线程
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
编程必备：JAVA多线程详解
拾一二的博客
06-14 8116
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
【Spring框架】
m0_71941456的博客
08-18 988
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 945
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 495
【代码】springboot网上商品订单转手系统bootpf
旅游网站
weixin_43213064的博客
08-16 1153
【代码】springboot旅游网站
Yolov8：模型部署到安卓端
最新发布
m0_70694811的博客
08-21 327
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
二叉树(源码+lw+部署文档+讲解等)
lpw1012的博客
08-21 453
🌞博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序技术领域和毕业项目实战，以及程序定制化开发、全栈讲解、就业辅导✌🌞👇🏻精彩专栏 推荐订阅👇🏻2023-2024年最值得选的微信小程序毕业设计选题大全：100个热门选题推荐✅2023-2024年最值得选的Java毕业设计选题大全：500个热门选题推荐✅Java精品实战案例《500套》
如何使用 Java 记录简化 Spring Data 中的数据实体
08-20 340
Java 开发人员一直依赖Spring Data来实现高效的数据访问。但是，随着Java Records的引入，数据实体的管理方式发生了重大变化。在本文中，我们将讨论 Java Records 在 Spring Data 应用程序中的集成。我们将探讨使用 Java 记录创建健壮的数据实体的好处，并提供真实世界的示例来展示它们在 Spring Data 中的潜力。Java 记录的力量：概述J...
微服务框架
Founder_Xiao_Xin的博客
08-20 602
在分布式系统中，服务可能失败导致雪崩，Hystrix 是防雪崩利器，具有服务降级、服务熔断、服务隔离、监控等防止雪崩的技术。服务降级：接口调用失败调用本地方法返回空。服务熔断：接口调用失败进入熔断方法返回错误信息。服务隔离：隔离服务之间相互影响。服务监控：记录服务调用的运行指标。在分布式系统中，一个业务因跨越不同数据库或不同微服务而包含多个子事务，要求所有子事务同时成功或失败，这就是分布式事务。例如某电商系统下单操作，需请求订单服务、账户服务、库存服务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值