详细讲解 —— 多线程初阶(一)认识线程(Java EE初阶)

Quartus Prime v18.1 standard-QuartusPrimeV18.1标准版安装过程 Quartus Prime v18.1 standard安装破解过程 下载方式1:官网下载: https://fpgasoftware.intel.com/18.1/?edition=standard&platform=windows 下载方式2:可以从我的网盘下载安装包(如果链接未时效的话): 链接:https://pan.baidu.com/s/1bq4_FcNPSflU1zGJv__rvA 提取码:o0in ----------------------------------. 阅读详情

认识线程

一、概念

什么是线程

一个线程就是一个 “执行流”. 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 “同时” 执行着多份代码.

为什么要有进程?

因为我们的系统支持多任务,这个就需要程序员来“并发编程”。(这里的并发编程是 并行 + 并发)。

为什么要有线程

多进程出现的问题

通过多进程,是完全可以实现并发编程的,但是有一点问题。

如果我们频繁的创建/销毁进程,这个事情的成本是比较高的。如果我们需要频繁的调度进程,这个事情成本也是比较高的。

创建进程就得分配资源:内存资源和文件资源。

销毁进程就得释放资源:内存资源和文件资源。

对于资源申请和释放,本身就是一个比较低效的操作。

如何解决这个问题

思路有两个:

  1. 进程池(比如数据库连接池,字符串常量池)。
    进程池虽然能解决上述频繁创建和销毁的问题,但是进程池太消耗系统的资源了,因为在进程池里面有很多闲置的进程。
  2. 使用线程来实现并发编程。
    线程比进程更轻量,每一个进程可以执行一个任务,每一个线程也能执行一个任务,他们都能实现并发编程。
    创建线程的成本比创建进程要低很多。
    销毁线程的成本比创建进程要低很多。
    调度线程的成本比创建进程要低很多。
    在Linux系统中,把 线程 称为 轻量级进程 (LWP)。

为什么线程比进程更轻量

进程的重量是重在资源的申请和释放上面。

线程是包含在进程中的,一个进程可以有多个线程,这多个线程公用同一份资源(同一份内存 + 文件),只是在创建进程的第一个线程的时候需要分配资源,之后进入这个进程的线程不需要再申请资源,这个时候创建线程的成本就会变低。

这个就会有一个疑问,多加一些线程,是不是效率就会进一步提升呢?

一般来说是会的,但是也不一定。

如果线程多了,这些线程就会要竞争同一个资源,这个时候,整体的速度就会收到限制(整体的硬件资源是有效的)。

线程和进程的区别和联系

  1. 进程包含线程。一个进程可以有一个或者多个线程,多个线程公用同一份资源。
  2. 进程和线程都是为了处理并发编程这样的场景。

    但是创建进程和销毁进程的效率低,而线程就比较的轻量,线程少了创建进程和销毁进程这个过程。

  3. 操作系统创建进程,要给进程分配资源,进程是操作系统分配资源的最小单位。

    操作系统创建线程,是在CPU中执行调度,线程是CPU执行调度的基本单位。

  4. 进程具有独立性,每一个进程都有各自独立的地址空间。一个进程挂了,不会影响其他的进程。

    但是在同一个进程中的多个线程,公用同一个内存空间。一个线程挂了,可能影响到其他的线程,甚至导致整个进程崩溃。

二、创建线程

Java中进行多线程编程,在Java标准库中,就提供了一个Thread类,用来操作线程。Thread类也可以视为是Java标准库提供的API。

创建好的Thread实例,其实和操作系统中的线程一一对应的关系。

操作系统提供了一组关于线程的API(C语言实现的),Java对这一组API进一步封装,就成为了Thread类。

方法一 继承 Thread 类

创建子类,继承Thread类,并重写run方法。

class MyThread extends Thread{
    //创建一个MyThread子类继承Thread类。
    @Override   //其中run方法中的内容描述了线程内部要执行的代码
    public void run() {
    //要注意的是,并不是写出这个代码,线程就创建出来了。这个是把要执行的代码准备好。
        System.out.println("hello thread!");
    }
}

public class TestDome1 {
 
    public static void main(String[] args) {
 
        Thread thread1 = new MyThread();   //创建MyThread子类的对象。
        thread1.start();   //当调用这里的start方法,才是真正的在系统中创建了线程。
                           //在这里才是真正的执行上面我们写的run方法中的代码。在调用start之前,系统没有创建出线程的。
    }
}

方法二 实现 Runnable 接口

通过Runnable来描述任务的内容,进一步的再把描述好的任务交给Thread实例

class MyRunnable implements Runnable{
    //继承接口
    @Override
    public void run() {
    //实现接口中的方法
        System.out.println("Hello Runnable");
    }
}

public class TestDome2 {
 
    public static void main(String[] args) {
 
        // 创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数。
        Thread thread1 = new Thread(new MyRunnable());  
        thread1.start();   //创建线程,执行代吗
    }
}

方法三 匿名内部类创建 Thread 子类对象

public class TestDome3 {
 
    public static void main(String[] args) {
 
        Thread thread = new Thread(){
    //创建出这个匿名内部类的实例
            @Override   //创建了一个匿名内部类,继承自Thread类,重写了run方法,
            public void run() {
 
                System.out.println("Hello Thread!!");
            }
        };
        thread.start();   //开始执行线程
    }
}

方法四 匿名内部类创建 Runnable 子类对象

public class TestDome4 {
 
    public static void main(String[] args) {
 
        //new Runnable,是针对这个创建的内部类,同时Runnable实例传给Thread的构造方法
        Thread thread =  new Thread(new Runnable() {
 
            @Override
            public void run() {
    //要执行的代码
                System.out.println("hello thread");
            }
        });
        thread.start();   //创建线程,执行代码。
    }
}

通常认为 匿名内部类创建 Runnable 子类对象 这中方法更好一点,能够做到让线程和线程执行的任务更好的解耦。(写代码一般希望,高内聚,低耦合)

Runnable单纯的只是描述了一个任务,至于这个任务是要通过一个进程来执行,还是线程来执行,还是协程来执行,Runnable本身不关心。

方法五 使用lambda 表达式

public class TestDome6 {
 
    public static void main(String[] args) {
 
        Thread thread1 = new Thread(()->{
    //使用lambda表达式来代替了Runnable。
            System.out.println("hello thread1");
        });
        thread1.start();
    }
}

上面的五种写法都很常见,希望大家都能够熟悉

三、线程之间并发执行

public class TestDome5 {
 
    public static void main(String[] args) {
 
        Thread thread1 = new Thread(new Runnable() {
    //使用匿名内部类创建 Runnable 子类对象
            @Override
            public void run() {
 
                while(true){
    //如果一个循环中不加任何限制,这个循环转的速度是非常快的,我们一般看不过来
                   //我们就可以再循环中加一个sleep操作,来强制让这个线程休眠一段时间。
                    System.out.println("hello thread");
                    try {
    //这个是让线程强行进入堵塞状态,单位是ms
                        Thread.sleep(1000);   //1000ms表示1s中之内这个线程不会到CPU中执行。
                    } catch (InterruptedException e) {
 
                        e.printStackTrace();   //抛出异常,线程被强制中断的异常。
                    }
                }
            }
        });
        thread1.start();

        //在进程中至少有一个线程,在一个Java进程中,会有一个调用main方法的线程
        //这个线程不是人为调动的,是系统自带的。
        while(true){
 
            System.out.println("hello main");
            try {
 
                Thread.sleep(1000);   //休眠一秒,线程堵塞一秒
            } catch (InterruptedException e) {
 
                e.printStackTrace();
            }
        }
    }
}

上面这个程序是:自己创建T线程和自动创建的main线程并发执行(在宏观上看起来同时执行)。

两个线程,都是打印一条就休眠1s,由代码运行结果图可知,当1s时间到了之后,系统先唤醒谁是不确定的(随机的)。

对于操作系统来说,内部对于线程之间的调度顺序,在宏观上可以认为是随机的(线程之间是抢占式执行),这个随机性会给多线程编程带来很多的麻烦。

四、多线程的优势-增加运行速度

可以观察多线程在一些场合下是可以提高程序的整体运行效率的。

public class TestDome7 {
 
	//在写一个比较长的整数常量的时候就可以通过_来进行分隔
    private static final long COUNT = 10_0000_0000;   //定义一个常量COUNT=10_0000_0000

    public static void main(String[] args) throws InterruptedException {
 
    	//使用串行
        serial();
        //使用并行
        concurrency();
    }
	//实现两个数自增10亿次
    private static void serial() {
 
    	//System.currentTimeMillis()  Java自带的记录当前系统的时间戳。
        long begin = System.currentTimeMillis();
        long a = 0;
        for(long i=0; i<COUNT; i++){
    //循环10亿次
            a++;
        }
        long b = 0;
        for(long i=0; i<COUNT; i++){
    //循环10亿次
            b++;
        }
        long end = System.currentTimeMillis();   //记录系统时间
        System.out.println("串行: " + (end - begin) + "ms");
    }

	//使用线程来实现两个数自增10亿次
    private static void concurrency() throws InterruptedException {
 
        long begin = System.currentTimeMillis();   //记录系统时间
        Thread thread1 = new Thread(()->{
    //第一个线程
            long a = 0;
            for(long i=0; i<COUNT; i++){
 
                a++;
            }
        });
        thread1.start();   //使用start函数,才创建了线程
        Thread thread2 = new Thread(()->{
    //第二个线程
            long b = 0;
            for(long i=0; i<COUNT; i++){
 
                b++;
            }
        });
        thread2.start();
		//在这里不能直接使用记录系统结束的时间。不要忘记了本身就有一个系统自带的mian线程
		//因为在这里是thread1,thread2,mian线程三个线程同时抢占式执行。
		//正确的应该是让main线程等待thread1和thread2线程结束,在记录结束时间
		//要使用join这个函数,这个函数就是要main函数等待线程结束。
        thread1.join();
        thread2.join();
        long end = System.currentTimeMillis();   //记录系统结束时间
        System.out.println("并行:" + (end - begin) + "ms");
    }
}

从上面的代码运行结果图可以看出来。串行执行的时候,时间大概是1700多ms。两个线程并发执行,时间大概是1000多ms,提升了接近50%。

但是并不是说,一个线程2000多ms,两个线程就是1000多ms。

这个要根据底层到底是并行执行,还是并发执行,只有在并行执行的时候,效率才会显著提高,但是我们并不确定到底是并发,还是并行,而且还有创建线程的开销。所以并不会完完全全的提升了一半。

用GraphPad Prism直出单细胞亚群堆叠柱状图 阅读详情

相关推荐

hCaptcha Enterprise绕过方案对比:四种Capsolver任务类型怎么选?

本文深入评测了hCaptcha Enterprise的四种Capsolver任务类型(HCaptchaEnterpriseTask、HCaptchaEnterpriseTaskProxyLess、HCaptchaTurboTask和HCaptchaTurboTaskProxyLess),分析其技术架构、性能表现及适用场景。通过基准测试和成本模型比较,帮助技术团队选择最优解决方案,提升自动化流程的验证通过率与成本效益。

rrr55的博客 325

线程

线程 线程的概念 线程 = 执行流程 + 控制平台 线程是进程的一条执行路径。 创建线程时,操作系统不为线程分配独立的资源(除了必要的数据支持),线程仍然使用所在进程的资源平台。 线程和进程的区别 进程是资源分配的最小单位,线程是CPU调度的最小单位 多线程处理的系统 多线程系统的特征 线程必须在一个进程中; 进程是资源分配单位,线程是调度单位; 一个进程中的所有线程共享资源。 多线程带来的好处: 1、多线程方便进行数据的共享和交流。 2、线程切换代价小。 3、提高了CPU的性能。 线程的状态

一直努力 295

在Windows11上安装ubuntu版linux系统并实现桌面图形化(WSL)

在Windows11上安装ubuntu版linux系统并实现桌面图形化(WSL),xfce桌面美化、安装google-chrome

NiKoJJ‘s Blog 1万+

线程资源分配与释放(转载)

很好的文章,提到内核线程与用户态线程以及资源的分配管理释放 https://www.jianshu.com/p/ea692d4f5e27

weixin_41783335的博客 1744

Android Settings 设置Preference置灰显示

使Preference置灰显示,不能点击。先调用Preference的setEnabled(false),再调用setShouldDisableView(true); 如果使置灰项恢复正常可点击,可调用setEnabled(true)。

随风而动 1050

USB驱动(URB)

本文介绍了Linux内核中USB驱动开发的核心概念URB(USB Request Block)。URB是主机与USB设备间传输数据的抽象结构体,包含目标设备、端点信息、数据缓冲区等关键字段。文章详细解析了URB的生命周期(分配、填充、提交、回调、释放)、四种传输类型(控制、批量、中断、等时)及其应用场景,并提供了鼠标设备的中断传输示例代码。最后强调了URB使用注意事项,包括DMA缓冲区分配、错误处理和资源释放等。URB作为USB驱动与内核通信的桥梁,是构建稳定USB驱动程序的基础。

m0_49476241的博客 917

线程开启需要占用的资源有哪些?

一、线程开启所占用的空间开销 【1】Thread内核数据占用:主要有OSID(线程的ID)和Context(存放CPU寄存器相关的资源)寄存器的状态会被保存到Context中,以便下次使用。因为多线程程序和主线程程序执行主要是依赖时间片切换(所以电脑使用中不会有卡顿情况)。通常系统分配一个时间片大约30ms,意思就是1秒中被分配至少33份,分别执行不同的线程。 【2】Thread环境块(了解) 【3】用户堆栈模式(主要部分):用户程序中的局部变量和参数传递所使用的堆栈,如果是引用类型则使用堆的空间,如

韦_恩的博客 5840

uniapp 开发小程序 使用 `uni.canvasToTempFilePath` 导出图片时遇到的 “fail fail canvas is empty“ 错误解决方法

问题的关键在于,在调用时需要正确的上下文对象。如果没有传入this(vue2)或instance(vue3),就会导致导出失败,提示错误。这也提醒我们,在使用类似这样的 API 时,要确保上下文传递正确,以便函数能够正常执行。希望这个排查过程和解决方案能帮助你解决类似的问题!

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 2332

【Java EE】多线程-初阶 多线程的一些基础用法

使⽤没有共享资源的模型适⽤共享资源只读,不写的模型a. 不需要写共享资源的模型b. 使⽤不可变对象直⾯线程安全(重点)a. 保证原⼦性b. 保证顺序性c. 保证可⻅性1.线程的优点创建⼀个新线程的代价要⽐创建⼀个新进程⼩得多与进程之间的切换相⽐,线程之间的切换需要操作系统做的⼯作要少很多线程占⽤的资源要⽐进程少很多能充分利⽤多处理器的可并⾏数量在等待慢速I/O操作结束的同时,程序可执⾏其他的计算任务。

2402_85428625的博客 3145

番外篇 | 复现HIC-YOLOv5,助力小目标物体的检测

在本文中提出了一种改进的YOLOv5算法:HIC-YOLOv5,用于小目标检测,具有更好的性能和较低的计算成本。🌈

小哥谈 1132

蓝桥杯 stm32 PWM 测量频率

参考 数据手册:比赛 的板子 上面有两个信号发生器,如下图。通过 扭动 可变电阻 (R40, R39), 来实现 PWM 频率的改变。PA15PB4。PA15,PB4分别使用TIM2_CH1TIM3_CH1来对频率进行捕获。

wuyiyu_的博客 2932

【Java EE初阶】多线程-初阶

使⽤没有共享资源的模型适⽤共享资源只读,不写的模型a. 不需要写共享资源的模型b. 使⽤不可变对象直⾯线程安全(重点)a. 保证原⼦性b. 保证顺序性c. 保证可⻅性1.线程的优点创建⼀个新线程的代价要⽐创建⼀个新进程⼩得多与进程之间的切换相⽐,线程之间的切换需要操作系统做的⼯作要少很多线程占⽤的资源要⽐进程少很多能充分利⽤多处理器的可并⾏数量在等待慢速I/O操作结束的同时,程序可执⾏其他的计算任务。

2402_85428625的博客 2466

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

JAVA EE_多线程-初阶(一)

我们可以先把进程理解为一个医院的门诊部,而门诊部是一个大类,这里面又有多个门诊,例如:内科门诊,外科门诊,妇科门诊,如果让张三一个人来做是负责不过来的,所以张三叫来了李四,王五,一个人负责一个门诊,这样就大大提高了效率。而张三,李四,王五就是线程,即多线程,其中张三是,因为李四线程和王五线程是由张三线程叫来的。

2401_82914354的博客 1340

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

【Java EE初阶 ---多线程(初阶)】多线程的使用

上篇博客,大概说明了计算机的历史和进程这一概念,初步对计算机的组成和运行有一定了解。这篇博客将正式进入对多线程的学习,希望对大家有所帮助~ ~ ~

optimistic_chen的博客 1308

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

【Java EE】多线程(一)

🙏小杨水平有限,欢迎各位大佬指点,相互学习进步!

QQ3447387928的博客 3859

【Java EE初阶 --- 多线程(初阶)】多线程的基本内容

既然有多线程,那么是不是也应该有单线程?答案是肯定的。其实单线程也叫进程,由上篇博客知道,进程中有多个线程,那么只有一个线程的进程就是单线程。我们的main主线程,之前的认知,main方法执行完毕,程序(进程)就结束了,那是因为之前没有接触到多线程程序,这篇博客将为我们认识多线程。。。

optimistic_chen的博客 1260

[Java EE] 多线程编程初阶

本文系统介绍了Java多线程编程的核心概念与技术。主要内容包括:1)线程基础,包括线程与进程的区别、创建线程的5种方法;2)线程状态管理,涵盖启动、中断、等待和休眠等操作;3)线程安全问题及解决方案,重点讲解synchronized关键字和volatile的应用;4)线程间协作机制wait/notify;5)多线程经典案例,包括单例模式、阻塞队列、线程池和定时器的实现。文章深入剖析了线程调度、锁机制、内存可见性等底层原理,并提供了大量实践示例,是掌握Java并发编程的全面指南。

Boop_wu的博客 1312

【Java EE初阶 --- 多线程(初阶)】多线程的实现案例

之前博客对多线程的是什么和基本内容都有详细了解,目前对于多线程的运用还很浅显,不能发挥出多线程应有的实力。这篇博客将带来多线程的基本应用,它会用到什么地方?又会带来什么高效的运行效率?我们又会学到什么?诸位尽情期待…

optimistic_chen的博客 1243

Java EE初阶——多线程进阶

CAS(Compare-And-Swap,比较并交换)是一种无锁(Lock-Free)的原子操作机制,用于在多线程环境下实现变量的同步。它通过硬件支持(如 CPU 指令)保证操作的原子性,避免了传统锁机制的线程阻塞和上下文切换开销,适用于高并发场景下的轻量级同步。内存地址(V):要更新的变量所在的内存位置。旧值预期(A):操作前假设的变量当前值。新值(B):准备更新的新值。从内存地址 V 中读取当前值V_cur。比较V_cur是否等于预期值 A:如果相等。

2302_80250536的博客 775

【JAVA EE初阶】多线程(上)

不同的操作系统之间不兼容,java却有“跨平台”特性,不需要任何修改,就可以在不同的系统上完成同样的功能,原因在于Java虚拟机,不同的主流系统都有各自的Java 虚拟机,Windows有Windows JVM,Linux有Linux JVM,这些JVM是不同的程序,但是上层支持的Java字节码是一致的。当一个线程循环进行上述读取变量操作的时候,就会把主内存中的数据,拷贝到该线程的工作内存中,后续另一个线程修改,也是先修改自己的工作内存,拷贝到主内存中。等先走的线程解锁,后走的线程才能加上锁,继续执行。

2301_80802299的博客 949

【Java EE】多线程-初阶 多线程案例

单个实例. 在一个 java 进程中, 要求指定的类,只能有唯一一个实例。(尝试 new 多个实例的时候, 就会直接编译报错)单例模式是校招中最常考的设计模式之⼀.单例模式具体的实现⽅式有很多. 最常⻅的是 “饿汉” 和 “懒汉” 两种.(掌握这两个, 应付面试 +日常开发)类加载的同时, 创建实例. 懒汉模式 懒汉模式-单线程版 类加载的时候不创建实例. 第⼀次使⽤的时候才创建实例.(如果不使用了,就会把创建实例的代价就节省下来了) 如果是首次调用 getlnstance, 那么此时 instance

2402_85428625的博客 1405

Java EE初阶——初识多线程

线程是操作系统进行运算调度的最小单位,包含在进程中,共享进程资源但拥有独立的栈空间和寄存器。线程的引入解决了进程创建/销毁成本高、上下文切换开销大、通信困难等问题,提高了资源利用率和程序并发性。线程通过共享地址空间降低内存开销,优化程序结构,降低上下文切换成本。Java线程基于操作系统线程实现,通过JVM创建和管理。创建线程的方法包括继承Thread类、实现Runnable接口、使用匿名内部类和lambda表达式。Thread类提供了管理线程的常见方法,如设置守护线程、获取线程状态等。线程的启动通过star

2302_80250536的博客 1072

【Java EE初阶---多线程(初阶)】初识计算机

经过了之前数据结构的学习,相信大多数人已经相比与开始的自己,已经有了十足的进步,结束数据结构的学习,为了揭开计算机背后神秘的面纱,同时为了更好迎接更多挑战,下面就让我们一起进入【Java EE初阶】部分吧!

optimistic_chen的博客 1199

【JavaEE初阶】多线程初阶上部

本篇目标: 认识多线程 掌握多线程程序的编写 掌握多线程的状态 掌握什么是线程不安全及解决思路 掌握 synchronized关键字

2301_80085602的博客 1612

Java EE初阶——线程安全

线程的状态。

2302_80250536的博客 1259
上一篇: Java线程的生命周期,终止与复位
下一篇: Java 处理 Excel:从 POI 到 SPL
javaYY_
博客等级 码龄4年 148粉丝 69原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值