JavaEE初阶:多线程 - 编程

这篇具有很好参考价值的文章主要介绍了JavaEE初阶:多线程 - 编程。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1.认识线程

我们在之前认识了什么是多进程,今天我们来了解线程。

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

引入进程这个概念,主要是为了解决并发编程这样的问题。因为cpu进入了多核心的时代,要想进一步提高程序的执行速度,就需要充分的利用CPU的多核资源。

其实多进程编程,已经可以解决并发编程的问题了,它已经可以利用起来cpu多核资源了,但是问题是:
进程太重了(消耗资源多、速度慢)

创建一个进程,开销比较大。

销毁一个进程,开销也比较大。           

调度一个进程,开销还比较大。

说进程重,主要就是重在资源分配/回收上。

线程应运而生,线程也叫做"轻量级进程",
解决并发编程问题的前提下,让创建,销毁,调度的速度更快一些
线程为啥更"轻",把申请资源/释放资源的操作给省下了。

1.1 进程和线程的区别

进程是包含线程的。每个进程至少有一个线程存在,即主线程。

进程和进程之间不共享内存空间。同一个进程的线程之间共享同一个内存空间。

进程是系统分配资源的最小单位,线程是系统调度的最小单位。

光靠文字可能有点抽象,我们举个例子:

多进程:

JavaEE初阶:多线程 - 编程,java,开发语言

 多线程:JavaEE初阶:多线程 - 编程,java,开发语言

在多进程中,启用了两套院子,那么启用的成本是比较大的,耗费的时间也是比较多的,但是在第二套中,院子和运输材料的通道都是公用的,那么就节省了成本。

在启动一个新的生产线时,就不需要重新启动一个院子,而是在原来的院子里启用,节省了许多的成本。

线程和进程的关系,是进程包含线程,
一个进程可以包含一个线程,也可以包含多个线程,但是不能没有。

对比下来,主要的优势在于:


只有第一个线程启动的时候,开销是比较大的,但是后续线程就省事了.,不论是启动还是关闭,耗费的资源都比启动/关闭一个进程要小。

同一个进程里的多个线程之间,共用了进程的同一份资源(主要指的是内存和文件描述符表)。这样这一部分资源就不需要重新启动或关闭。

操作系统,实际调度的时候,是以线程为单位进行调度的。

之前介绍的,,PCB里的状态,上下文,优先级,记账信息,都是每个线程有自己的。各自记录各自的但是同一个进程里的PCB之间, ,pid是一样的,内存指针和文件描述符表也是一样的。

那么既然线程这么好,可不可以无限制的在一个进程中增加线程呢?

并不可以,线程如果太多,核心数量有限,那么不少的开销就会浪费在线程调度上了,但是在多进程中就不会出现这样的状况。

线程模型,天然就是资源共享的.多线程争抢同一个资源(同一个变量)非常容易触发的.
进程模型,天然是资源隔离的.不容易触发.进行进程间通信的时候,多个进程访问同一个资源,可能会出问题.

 

1.2 多线程编程

本身关于线程的操作,操作系统提供的API,我们只需要学习Java提供的API就好了。

Java操作多线程,最核心的类 :Thread 

JavaEE初阶:多线程 - 编程,java,开发语言

先在src下创建一个包,接着再创建一个类 

JavaEE初阶:多线程 - 编程,java,开发语言

创建好主函数后,我们新建一个Thread的对象

Thread t = new Thread();

但是我们还需要一个类,新建一个Mythread类,并且重写run方法

class MyThread extends Thread{
    @Override
    public void run() {
            System.out.println("hello world");
    }
}

然后在main中,开始启动一个特殊的方法:

t.start;

完整的代码:

class MyThread extends Thread{
    @Override
    public void run() {
            System.out.println("hello world");
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
            t.start();
            System.out.println("hello main");
    }
}

这样一个代码,就新启动了一个线程,使得打印hello world和打印hello main是以完全不同的方式来完成的。

start这里的工作,就是创建了一个新的线程,新的线程负责执行重写过后的t.run。

具体的执行方法,就是start这个方法会调用操作系统的API,通过操作系统内核创建新线程的PCB,并且把要执行的指令交给PCB,当PCB被调度到CPU上执行的时候,也就执行到了线程run方法中的代码了。

JavaEE初阶:多线程 - 编程,java,开发语言
通过具体的结果,,两个线程是同时进行的,并且可以看做是一次运行时无序,可能先打印world,也可能先打印main。

但是运行的时候不一定谁先谁后,
操作系统调度线程的时候,"抢占式执行",具体哪个线程先上,哪个线程后上,不确定,取决于操作系统调度器具体实现策略.
虽然有优先级,但是在应用程序层面上无法修改.
从应用程序(代码)的角度,看到的效果,就好像是线程之间的调度顺序是"随机"的一样.

内核里本身并非是随机.但是干预因素太多,并且应用程序这一层也无法感知到细节,就只能认为是随机的了。
为啥会有线程安全问题?罪魁祸首,万恶之源,就是这里的抢占式执行,随机调度。

start和run的区别

start是真正创建了一个线程(从系统这里创建的),线程是独立的执行流。


run 只是描述了线程要干的活是啥,如果直接再main中调用run,此时没有创建新线程,全是main线程一个人干活。相当于还是单线程。

可以使用jdk自带的工具jconsole查看当前的java进程中的所有线程. 

JavaEE初阶:多线程 - 编程,java,开发语言
        

JavaEE初阶:多线程 - 编程,java,开发语言
这里面就可以看到进程。同时进程中还有很多个线程。除了我们使用的,其他的都是JVM自带的JavaEE初阶:多线程 - 编程,java,开发语言

 JavaEE初阶:多线程 - 编程,java,开发语言

 1.3 多线程的五种创建方法

1.继承Thread,重写run方法

class MyThread extends Thread{
    @Override
    public void run() {
            System.out.println("hello world");
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
            t.start();
            System.out.println("hello main");
    }
}

也就是上面详细介绍的方法。

2.实现 Runnable 接口

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("hello thread");
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread t = new Thread(runnable);
        t.start();
    }
}

Runnable 作用,是描述一个“要执行的任务”,然后把这个任务交给Thread来执行。

好处就是这样写可以解耦合,让线程和线程之间干的活要分开。

3.使用匿名内部类,继承 Thread

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("hello");
            }
        };
        t.start();
    }
}

这里面创建了一个Thread的子类,并且创建了子类的实例,让 t 引用指向该实例。

4.使用匿名内部类,实现 Runable

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello demo4");
            }
        });
        t.start();
    }
}

这个写法和2本质相同,只不过是把Runnable任务交给匿名内部类的语法。

此处是创建了一个类,实现Runnable,同时创建了类的实例,并且传给Thread的构造方法。

5.使用 Lambda 表达式(推荐)

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello demo5");
        });
        t.start();
    }
}

使用lambda表达式来描述,直接把lambda传给Thread构造方法。

 文章来源地址https://www.toymoban.com/news/detail-651301.html

到了这里,关于JavaEE初阶:多线程 - 编程的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【JavaEE初阶】 线程池详解与实现

    线程池,是一种线程的使用模式,它为了降低线程使用中频繁的创建和销毁所带来的资源消耗与代价。 通过创建一定数量的线程,让他们时刻准备就绪等待新任务的到达,而任务执行结束之后再重新回来继续待命。 想象这么一个场景: 在学校附近新开了一家快递店,老板很

    2024年02月06日
    浏览(35)
  • 【JavaEE初阶】 线程安全的集合类

    原来的集合类, 大部分都不是线程安全的. Vector, Stack, HashTable, 是线程安全的(不建议用), 其他的集合类不是线程安全的. 为什么不建议使用呢? 因为我们在使用的时候,这些类就会自动的加锁,虽然编译器会自动优化为没有锁竞争的线程进行锁消除的优化,但是呢万一编译器没

    2024年02月08日
    浏览(33)
  • 多线程(JavaEE初阶系列4)

    目录 前言: 1.单例模式 1.1饿汉模式 1.2懒汉模式 1.3结合线程安全下的单例模式 1.4单例模式总结 2.阻塞式队列 2.1什么是阻塞队列 2.2生产者消费者模型 2.2.1 上下游模块之间进行“解耦合” 2.2.2削峰填谷 2.3阻塞队列的实现 结束语: 在上节中小编主要与大家分享了多线程中遇到

    2024年02月15日
    浏览(49)
  • 多线程(JavaEE初阶系列7)

    目录 前言: 1.常见的锁策略 1.1乐观锁和悲观锁 1.2轻量级锁和重量级锁 1.3自旋锁和挂起等待锁 1.4互斥锁与读写锁 1.5可重入锁与不可重入锁 1.6公平锁与非公平锁 2.CAS 2.1什么是CAS 2.2自旋锁的实现 2.3原子类 3.synchronized 3.1synchronized的原理以及基本特点 3.2偏向锁 3.3轻量级锁 3.4重

    2024年02月14日
    浏览(34)
  • 多线程(JavaEE初阶系列2)

    目录 前言: 1.什么是线程 2.为什么要有线程 3.进程与线程的区别与联系 4.Java的线程和操作系统线程的关系 5.多线程编程示例 6.创建线程 6.1继承Thread类  6.2实现Runnable接口 6.3继承Thread,使用匿名内部类 6.4实现Runnable接口,使用匿名内部类 6.5lambda表达式创建Runnable子类对象 7.

    2024年02月15日
    浏览(37)
  • JavaEE初阶Day 6:多线程(4)

    前序 :针对Day 5结尾的count++ 多线程的执行,是 随机调度抢占式 的执行模式,某个线程执行指令过程中,当它执行到任何一个指令的时候,都有可能被其他线程把它的CPU抢占走 实际并发执行,由于 上述原因 以及 count++本质是CPU的三个指令 ,两个线程执行指令的相对顺序就可

    2024年04月14日
    浏览(28)
  • 【JavaEE初阶】多线程(四)阻塞队列 定时器 线程池

    概念 阻塞队列是一种特殊的队列. 也遵守 “ 先进先出 ” 的原则. 阻塞队列能是一种线程安全的数据结构, 并且具有以下特性: 当队列满的时候, 继续入队列就会阻塞, 直到有其他线程从队列中取走元素. 当队列空的时候, 继续出队列也会阻塞,直到有其他线程往队列中插入元素

    2023年04月26日
    浏览(53)
  • JavaEE 初阶篇-深入了解多线程等待与多线程状态

    🔥博客主页: 【 小扳_-CSDN博客】 ❤感谢大家点赞👍收藏⭐评论✍ 文章目录         1.0 线程等待         1.1 线程等待 - join() 方法         1.1.1 main 线程中等待多个线程         1.1.2 main 线程等待 t2 线程且t2 线程等待 t1 线程         1.1.3 其他线程阻塞等待 main 线程

    2024年04月17日
    浏览(36)
  • JavaEE初阶:多线程 - Thread 类的基本用法

    上次我们了解了多线程的五种创建方法,今天来学习Thread的基本用法。 目录 run和start Thread常见的构造方法 Thread的几个常见属性 后台线程 是否存活 线程终止 1.使用标志位 2.使用Thread自带的标志 等待线程 首先需要理解Thread的run和start的区别: run描述了线程要做的工作,star

    2024年02月12日
    浏览(32)
  • JAVAEE初阶 网络编程(二)

    在构造一个简单的服务器之前,我们需要了解到一些传输层提供给应用层的一些API。 1.1 服务器端的代码分析。 在服务器端,第一步我们要创建DatagramSocket对象。 socket对象是在内存中的,针对这个内存对象操作就会改变网卡。 一个主机上的端口号是整数,并且只能被一个进程

    2024年01月21日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包