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

【后端开发】JavaEE初阶—线程的理解和编程实现

article 2024/9/22 4:59:24

前言：

🌟🌟本期讲解多线程的知识哟~~~，希望能帮到屏幕前的你。

🌈上期博客在这里：【后端开发】JavaEE初阶——计算机是如何工作的？？？-CSDN博客

🌈感兴趣的小伙伴看一看小编主页：GGBondlctrl-CSDN博客

​ 

目录

📚️1.引言

📚️2.线程内部原理

2.1线程的作用

2.2线程和进程的区别

2.3线程的缺点

1.引入更多的线程

2.线程冲突

2.4 线程原理总结

📚️3.多线程编程

3.1代码实现

3.2两个线程执行

3.3线程创建的方式

1.直接继承Thread并重写run方法

2.实现Runnable接口，重写run方法

3.继承Thread，重写run并使用匿名内部类 

4.实现Runnable，重写run，使用匿名内部类

 5.lambda表达式

📚️5.总结 

 ​

📚️1.引言

Hello!!!家人们，小编又回来啦，上期讲解了关于计算机中的重要知识进程，后面我们讲到进程在频繁的申请和销毁时会造成系统开销很大，那么就要引入线程了，接下来本期就开始讲解关于后端开发的重要知识“多线程”，开始发车了。加油加油~~~🥳🥳🥳

且听小编讲解，包你学会！！！

📚️2.线程内部原理

2.1线程的作用

线程：线程可以看做是轻量化的进程

注意：线程既可以保持独立调度执行，满足了并发执行，并且省去了分配资源和释放资源带来的额外开销；这就使得线程较好的弥补了进程的缺点

2.2线程和进程的区别

前面用PCB来描述进程，本期用PCB来表示线程

操作系统对于“多任务的调度”本质上是对PCB进程的调度，而线程和进程属性基本一致，都有状态，优先级，记账信息等；

这两者的较大区别：

 此时可以看到：每个进程要申请一个内存空间，而每一个线程都共用一个内存空间；

注意：此时就有一个重要的属性概念：内存指针，多线程的PCB的内存指针指向的是同一个内存地址；那么在第一个线程申请了分配资过后，后面创建的线程就不用分配资源了，直接省去了资源分配带来的系统消耗；

当然除了内存空间，还有文件描述附表（操作硬盘）这也是多线程共用的；

 注意：能够把资源共享的线程，分成一组叫做线程组，线程组是进程的一部分

图例如下：

 注意：

在没有线程之前，进程既是分配资源的基本单位，也是调度执行的基本单位。

线程存在后，进程是资源分配的基本单位，线程是调度执行的基本单位；

对于两者有啥意义上的区别：

假如有一个桌子上有40个水果，要把这个水果吃完，就有两种方式

第一种：

第二种：

此时就能够发现：第一种模拟的是进程的方法，第二种模拟的是线程的方法，那么就可以发现：进程种方法在并发执行任务时会不断分配资源（就是房间），线程执行的时候，就公用一个内存空间（公用一个房间），就不会重新分配新资源；

2.3线程的缺点

1.引入更多的线程

图例如下：

此时可以看到，当我们引入更多的线程之后，他们之间会相互竞争，会造成拥挤（即抢占去吃苹果），这就会造成，引入过多的线程后，执行效率反而不高了；

结果：当线程有太多的时候，线程会相互竞争CPU资源了（CPU的核心数量是有限的），这样不但不会提升执行效率，还会增加系统调度的开销；

2.线程冲突

 

假如线程1和线程二看上了同一块苹果，那么就会存在两个线程之间的冲突，苹果是谁的，也不确定

结果：线程冲突，会导致代码出现逻辑上的错误即线程安全问题； 

2.4 线程原理总结

1.每个线程都是一个独立的执行流，都可以单独参与到CPU的调度中去

2.每个进程都有自己的资源，进程中的线程共用这一份资源

3.进程和进程之间不会相互影响，但是进程中的线程之间，当一个线程抛出异常，其他线程会受到影响，导致整个线程异常终止

4同一个进程内的线程之间会相互影响，导致线程安全问题

5.线程不是越多越好，太多了会导致系统调度开销增大

📚️3.多线程编程

在写代码的时候可以用多进程编程，和多线程编程；但是在Java库中对应的多进程编程是没有对应API的，并且前面也讲到多线程编程在资源分配上优于多进程编程，所以就用多线程编程；

3.1代码实现

首先创建一个类去继承Thread类，这里的Thread类是由java.lang包里的，并要重写run()方法，这个方法即是线程的入口，代码如下：

class mythread extends Thread{
    //重写run方法,该线程的入口方法
    @Override
    public void run(){
       
        }
    }
}

注意事项;

1.这里的方法不用调用，当线程创建好之后，JVM会自动帮我们进行调用；

2.每个进程中都有至少有一个线程，进程中的第一个线程就是主线程，所以我们的main方法就是主线程的入口；

3.Thread类本身会有一个run（）方法

创建实例，调用start方法，这样才会在系统内核中创建真正的线程，代码如下：

public static void main(String[] args) {
        //构造实例
        mythread t=new mythread();
        //Thread t=new Thread();
        t.start();

 注意:

在实例化对象时，可以直接用mythread类，但是也可以使用Thread来接收，这就是完成了一个向上转型

这里如果直接new一个Thread的对象后，创建线程后，JVM会自动调用这个类本身的run() 

我们这里简单演示一下，线程的代码和结果；

public class threadDeom1 {
    public static void main(String[] args) {
        //构造实例
        //mythread t=new mythread();
        Thread t=new mythread();
        t.start();
    }
}
//写一个类继承thrad
class mythread extends Thread{
    //重写run方法,该线程的入口方法
    @Override
    public void run(){
        while (true){
            System.out.println("这是thread线程");
            //防止打印过快
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                throw new RuntimeException();//抛出异常
            }
        }
    }
}

 注意：这里的Sleep是线程休眠的意思，1000代表的ms所以这里就是一秒，并且此时还要抛出异常，程序才能正常执行；

结果：

此时这张图只是一部分，线程会不断执行，这里小编只是截取了一小部分；

3.2两个线程执行

这里的代码如下：

public static void main(String[] args) {
        //构造实例
        //mythread t=new mythread();
        Thread t=new mythread();
        t.start();
       while (true){
            System.out.println("这是main线程");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                throw new RuntimeException();
            }
        }
    }
}
//写一个类继承thrad
class mythread extends Thread{
    //重写run方法,该线程的入口方法
    @Override
    public void run(){
        while (true){
            System.out.println("这是thread线程");
            //防止打印过快
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                throw new RuntimeException();//抛出异常
            }
        }
    }

这里存在两个死循环，但是这两个输出语句仍然进行了打印，这是为什么呢？？？

注意：线程是两个独立的执行流，所以此处在调用start方法后，线程就有两种，一路继续沿着main方法、即主线程，另一种就是进入线程的run方法；

这里的打印顺序是不确定的，因为操作系统内核中有“调度器这一模块”，即一种随机调度的效果

随机调度：

一个线程什么时候被CPU调度是不确定的；

一个线程什么时候从CPU上下来，给其他线程让位也是不确定的；

上述代码输出结果：

这里大家可以多次实验一下，可以看到为第一个输出的总是main线程呢？？？

注意：当使用start方法后，主线程会直接向下执行，但是操作系统的内核就要根据刚才的api创建出线程来，并执行run方法；又因为创建线程也有开销（比进程小很多，但是不为0），所以会导致主线程更快；

3.3线程创建的方式

1.直接继承Thread并重写run方法

代码实现：

 public static void main(String[] args) {
        //构造实例
        //mythread t=new mythread();
        Thread t=new mythread();
        t.start();
      
    }
}
//写一个类继承thrad
class mythread extends Thread{
    //重写run方法,该线程的入口方法
    @Override
    public void run(){
       
    }

注意：重写为了特定功能的展开，满足我们特定的需求；

2.实现Runnable接口，重写run方法

 代码实现如下：

public static void main(String[] args) {
        Runnable runnable=new mythread1();
        //实现runnable接口
        Thread t=new Thread(runnable);
        t.start();
        //第二种写法
       Thread t=new Thread(new mythread1());
       t.start();
        //第三种写法
         mythread1 mythread1=new mythread1();
        Thread t=new Thread(mythread1);
        t.start();
        
    }
}
class mythread1 implements Runnable{
    @Override
    public void run() {
       
    }

注意：小编这里介绍了三种写法，其实本质都是一样的，都是输入线程对象，并且在实例化对象时，一个使用了向上转型，还有一个没有使用向上转型而已；

3.继承Thread，重写run并使用匿名内部类 

代码实现如下：

public static void main(String[] args) {
        Thread t=new Thread(){
            public void run(){
               
            }
        };
        t.start();
        while (true){
            System.out.println("这是main线程");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                throw new RuntimeException();
            }
        }
    }

注意：{}中可以主要是定义子类的属性和方法，这里最主要还是进行run方法的重写；下面的死循环是为了方便进行两种线程存在执行情况；

4.实现Runnable，重写run，使用匿名内部类

代码实现如下：

 public static void main(String[] args) {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
               
            }
        });
        t.start();
        while (true){
            System.out.println("这是mian线程");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                throw new RuntimeException();
            }
        }
    }

注意：这里Thread括号里使用的参数，是Runnable接口匿名内部类的实例，这个就像是之前在lambda表达式中，比较器的写法，这里大家可以参考一下：【数据结构】Lambda表达式的应用-CSDN博客

 5.lambda表达式

代码如下：

public static void main(String[] args) {
        //lambda表达式
        Thread t=new Thread(()->{
            while (true){
               
            }
        });
        t.start();
        while (true){
            System.out.println("这是main线程");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                throw new RuntimeException();
            }
        }
    }

注意：这里的lambda表达式中（）内没有参数，其实这就是实现Runnable接口匿名内部类的一种写法，由于只有一个方法，且参数为空，所以这个括号内也就是空，并且后面的方法体就是重写run()方法；

📚️5.总结 

💬💬小编本期讲解了JavaEE初阶的重要知识线程，以及和进程之间的关系，以及线程的优点和缺点，并且讲述了在编程中线程的实现，以及线程的创建的五种方式，还附上了代码供小伙伴参考参考~~~

代码上传Gitee啦：朱海洋/Thread (gitee.com)

🌅🌅🌅~~~~最后希望与诸君共勉，共同进步！！！

💪💪💪以上就是本期内容了， 感兴趣的话，就关注小编吧。

                                                                 😊😊  期待你的关注~~~


http://www.kler.cn/news/314213.html

相关文章：

  • C#用SDK打开海康工业相机,callback取图Bitmap格式，并保存
  • 如何使用ssm实现基于Web的数字家庭网站设计与实现+vue
  • Netty+HTML5+Canvas 网络画画板实时在线画画
  • 嵌入式 开发技巧和经验分享
  • 电脑ip地址怎么换地区：操作步骤与利弊分析
  • Elasticsearch如何排序，分页以及高亮查询
  • Rust GUI框架 tauri V2 项目创建
  • 如何安装部署kafka
  • JAVA自助高效安全无人台球茶室棋牌室系统小程序源码
  • 篮球运动场景物体检测系统源码分享
  • 解决在Nignx下Thinkphp路由不生效问题
  • 音视频入门基础：AAC专题（7）——FFmpeg源码中计算AAC裸流每个packet的size值的实现
  • 计算机网络（八） —— Udp协议
  • YMTC Xtacking 4.0（Gen5）技术深度分析
  • MCS-51汇编
  • Linux进程（一）
  • 推动高效能：东芝TB67H301FTG全桥直流电机驱动IC
  • Spring 框架简介 ----- Java 开发利器
  • 【赵渝强老师】K8s中的Deployment控制器
  • 研究生如何利用 ChatGPT 帮助开展日常科研工作？
  • 【Taro】初识 Taro
  • Mysql_使用简介
  • 【计网】从零开始使用TCP进行socket编程 ---服务端业务模拟Xshell
  • 搜维尔科技：OptiTrack将捕捉到的人类动作数据映射到人形机器人的各个关节上进行遥操作
  • 【C#】VS插件
  • 【C#生态园】探秘.NET依赖注入：六种流行容器横向对比
  • SpringBoot如何在使用MongoRepository时启用@Created
  • [Python数据拟合与可视化]：使用线性、多项式、指数和高斯模型拟合数据
  • 【Stm32】从零建立一个工程
  • Science Robotic 内在触觉实现直观的物理人机交互