juc并发线程学习笔记(一)

本系列会更新我在学习juc时的笔记和自己的一些思想记录。如有问题欢迎联系。

并发编程

进程与线程

1.进程和线程的概念

程序是静态的,进程是动态的

进程
  • 程序由指令和数据组成,但这些指令要运行,数据要读写,就必须将指令加载至 CPU,数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的
  • 当一个程序被运行,从磁盘加载这个程序的代码至内存,这时就开启了一个进程。
  • 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程(例如记事本、画图、浏览器等),也有的程序只能启动一个实例进程(例如网易云音乐、360 安全卫士等)
线程
  • 一个进程之内可以分为一到多个线程。
  • 一个线程就是一个指令流,将指令流中的一条条指令以一定的顺序交给 CPU 执行
  • Java 中,线程作为最小调度单位,进程作为资源分配的最小单位。 在 windows 中进程是不活动的,只是作为线程的容器
进程和线程对比
  • 进程基本上相互独立的,而线程存在于进程内,是进程的一个子集
  • 进程拥有共享的资源,如内存空间等,供其内部的线程共享
  • 进程间通信较为复杂:同一台计算机的进程通信称为 IPC(Inter-process communication)。不同计算机之间的进程通信,需要通过网络,并遵守共同的协议,例如 HTTP
  • 线程通信相对简单,因为它们共享进程内的内存,一个例子是多个线程可以访问同一个共享变量
  • 线程更轻量,线程上下文切换成本一般上要比进程上下文切换低

2.并行和并发的概念

并发

并发能力:同一时间应对多件事情的能力。

单核 cpu 下,线程实际还是 串行执行 的。操作系统中有一个组件叫做任务调度器,将 cpu 的时间片(windows下时间片最小约为 15 毫秒)分给不同的程序使用,只是由于 cpu 在线程间(时间片很短)的切换非常快,人类感觉是 同时运行的 。总结为一句话就是: 微观串行,宏观并行 ,一般会将这种 线程轮流使用 CPU 的做法称为并发, concurrent。

并行

多核 cpu下,每个 核(core) 都可以调度运行线程,这时候线程可以是并行的。

引用 Rob Pike 的一段描述:

  • 并发(concurrent)是同一时间应对(dealing with)多件事情的能力
  • 并行(parallel)是同一时间动手做(doing)多件事情的能力

例子:

3.线程基本应用

应用之异步调用(案例1)

以调用方角度来讲,如果

  • 需要等待结果返回,才能继续运行就是同步
  • 不需要等待结果返回,就能继续运行就是异步

1) 设计

多线程可以让方法执行变为异步的(即不要巴巴干等着)比如说读取磁盘文件时,假设读取操作花费了 5 秒钟,如果没有线程调度机制,这 5 秒 cpu 什么都做不了,其它代码都得暂停...

//同步
@Slf4j(topic = "c.Sync")
public class Sync {

    public static void main(String[] args) {
        FileReader.read(Constants.MP4_FULL_PATH);
        log.debug("do other things ...");
    }

}

//异步
@Slf4j(topic = "c.Async")
public class Async {

    public static void main(String[] args) {
        new Thread(() -> FileReader.read(Constants.MP4_FULL_PATH)).start();
        log.debug("do other things ...");
    }

}

2) 结论

  • 比如在项目中,视频文件需要转换格式等操作比较费时,这时开一个新线程处理视频转换,避免阻塞主线程
  • tomcat 的异步 servlet 也是类似的目的,让用户线程处理耗时较长的操作,避免阻塞 tomcat 的工作线程
  • ui 程序中,开线程进行其他操作,避免阻塞 ui 线程

充分利用多核 cpu 的优势,提高运行效率。想象下面的场景,执行 3 个计算,最后将计算结果汇总。

计算 1 花费 10 ms
计算 2 花费 11 ms
计算 3 花费 9 ms
汇总需要 1 ms

  • 如果是串行执行,那么总共花费的时间是 10 + 11 + 9 + 1 = 31ms
  • 但如果是四核 cpu,各个核心分别使用线程 1 执行计算 1,线程 2 执行计算 2,线程 3 执行计算 3,那么 3 个线程是并行的,花费时间只取决于最长的那个线程运行的时间,即 11ms 最后加上汇总时间只会花费 12ms

注意
需要在多核 cpu 才能提高效率,单核仍然时是轮流执行

1) 设计

@Fork(1)
@BenchmarkMode(Mode.AverageTime)//测试模式,统计程序平均时间
@Warmup(iterations=3)//热身三次
@Measurement(iterations=5)//五轮测试取平均值
public class MyBenchmark {
    static int[] ARRAY = new int[1000_000_00];
    static {
        Arrays.fill(ARRAY, 1);
    }
    @Benchmark
    public int c() throws Exception {
        int[] array = ARRAY;
        FutureTask<Integer> t1 = new FutureTask<>(()->{
            int sum = 0;
            for(int i = 0; i < 250_000_00;i++) {
                sum += array[0+i];
            }
            return sum;
        });
        FutureTask<Integer> t2 = new FutureTask<>(()->{
            int sum = 0;
            for(int i = 0; i < 250_000_00;i++) {
                sum += array[250_000_00+i];
            }
            return sum;
        });
        FutureTask<Integer> t3 = new FutureTask<>(()->{
            int sum = 0;
            for(int i = 0; i < 250_000_00;i++) {
                sum += array[500_000_00+i];
            }
            return sum;
        });
        FutureTask<Integer> t4 = new FutureTask<>(()->{
            int sum = 0;
            for(int i = 0; i < 250_000_00;i++) {
                sum += array[750_000_00+i];
            }
            return sum;
        });
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
        new Thread(t4).start();
        return t1.get() + t2.get() + t3.get()+ t4.get();
    }
    @Benchmark
    public int d() throws Exception {
        int[] array = ARRAY;
        FutureTask<Integer> t1 = new FutureTask<>(()->{
            int sum = 0;
            for(int i = 0; i < 1000_000_00;i++) {
                sum += array[0+i];
            }
            return sum;
        });
        new Thread(t1).start();
        return t1.get();
    }
}

在单核的情况下,多线程和单线程效率基本一致,多线程会有上下文切换的耗时。

在多核的情况下,多线程比单线程就会效率翻倍。

2) 结论

单核 cpu 下,多线程不能实际提高程序运行效率,只是为了能够在不同的任务之间切换,不同线程轮流使用cpu ,不至于一个线程总占用 cpu,别的线程没法干活。

多核 cpu 可以并行跑多个线程,但能否提高程序运行效率还是要分情况的。

  • 有些任务,经过精心设计,将任务拆分,并行执行,当然可以提高程序的运行效率。但不是所有计算任务都能拆分(参考后文的【阿姆达尔定律】)
  • 也不是所有任务都需要拆分,任务的目的如果不同,谈拆分和效率没啥意义

IO 操作不占用 cpu,只是我们一般拷贝文件使用的是【阻塞 IO】,这时相当于线程虽然不用 cpu,但需要一直等待 IO 结束,没能充分利用线程。所以才有后面的【非阻塞 IO】和【异步 IO】优化

Java线程

1.创建和运行线程

创建线程对象

// 创建线程对象
Thread t = new Thread() {
 public void run() {
 // 要执行的任务
 }
};
// 启动线程,交给任务调度器,分配时间片,交给时间片去执行。
t.start();

例如:

方法一:直接使用 Thread

@Slf4j(topic = "c.Test1")
public class Test1 {

    public static void test2() {

        Thread t = new Thread(()->{ log.debug("running"); }, "t2");

        t.start();
    }
    public static void test1() {
        //匿名内部类的写法
        Thread t = new Thread(){
            @Override
            public void run() {
                log.debug("running");
            }
        };
        //创建线程的时候可以给其指定名称
        t.setName("t1");
        t.start();

    }
}

方法二:使用 Runnable 配合 Thread

把【线程】和【任务】(要执行的代码)分开

  • Thread 代表线程
  • Runnable 可运行的任务(线程要执行的代码)

Runnable源码,如果接口中有@FunctionalInterface注解,则可以被lambda简化。如果一个接口中有多个抽象接口,是没办法用lambda简化的。

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

@Slf4j(topic = "c.Test2")
public class Test2 {
    public static void main(String[] args) {
        //果接口中有@FunctionalInterface注解,则可以被lambda简化
        Runnable r = () -> {log.debug("running");};

        Thread t = new Thread(r, "t2");

        t.start();
    }
}

原理之 Thread  Runnable 的关系

分析 Thread 的源码,理清它与 Runnable 的关系

小结

  • 方法1 是把线程和任务合并在了一起,方法2 是把线程和任务分开了
  • 用 Runnable 更容易与线程池等高级 API 配合
  • 用 Runnable 让任务类脱离了 Thread 继承体系,更灵活

都是走的线程里的run方法。

方法三:FutureTask 配合 Thread

FutureTask 能够接收 Callable 类型的参数,用来处理有返回结果的情况

FutureTask源码分析:

实现一个RunnableFuture的接口

public class FutureTask<V> implements RunnableFuture<V> {

RunnableFuture接口又继承了Runnable和Future

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

Future里有get方法返回任务执行结果

    V get() throws InterruptedException, ExecutionException;

    /**
     * Waits if necessary for at most the given time for the computation
     * to complete, and then retrieves its result, if available.
     *
     * @param timeout the maximum time to wait
     * @param unit the time unit of the timeout argument
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an
     * exception
     * @throws InterruptedException if the current thread was interrupted
     * while waiting
     * @throws TimeoutException if the wait timed out
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

Callable源码分析

Callable可以配合FutureTask让任务执行完了,将结果传给其他线程

能抛出异常

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

实例代码:


// 创建任务对象
FutureTask<Integer> task3 = new FutureTask<>(() -> {
 log.debug("hello");
 return 100;
});
// 参数1 是任务对象; 参数2 是线程名字,推荐
new Thread(task3, "t3").start();
// 主线程阻塞,同步等待 task 执行完毕的结果
Integer result = task3.get();
log.debug("结果是:{}", result);

输出:

19:22:27 [t3] c.ThreadStarter - hello
19:22:27 [main] c.ThreadStarter - 结果是:100

2.查看进程线程的方法

windows
  • 任务管理器可以查看进程和线程数,也可以用来杀死进程
  • tasklist 查看进程 (tasklist | findstr java)
  • taskkill 杀死进程 (taskkill /F /PID 280660)
linux
  • ps -fe 查看所有进程
  • ps -fT -p  查看某个进程(PID)的所有线程
  • kill 杀死进程
  • top 按大写 H 切换是否显示线程
  • top -H -p  查看某个进程(PID)的所有线程
Java
  • jps 命令查看所有 Java 进程
  • jstack  查看某个 Java 进程(PID)的所有线程状态
  • jconsole 来查看某个 Java 进程中线程的运行情况(图形界面)可以在window+r里直接打印

jconsole 远程监控配置

  • 需要以如下方式运行你的 java 类

java -Djava.rmi.server.hostname=`ip地址` -Dcom.sun.management.jmxremote -
Dcom.sun.management.jmxremote.port=`连接端口` -Dcom.sun.management.jmxremote.ssl=是否安全连接 -
Dcom.sun.management.jmxremote.authenticate=是否认证 java类

不需要就false,ip地址和连接端口在输入后记得把`去掉

  • 修改 /etc/hosts 文件将 127.0.0.1 映射至主机名

如果要认证访问,还需要做如下步骤

  • 复制 jmxremote.password 文件
  • 修改 jmxremote.password 和 jmxremote.access 文件的权限为 600 即文件所有者可读写
  • 连接时填入 controlRole(用户名),R&D(密码)

3.线程运行的原理

栈与栈帧

ava Virtual Machine Stacks (Java 虚拟机栈)

我们都知道 JVM 中由堆、栈、方法区所组成,其中栈内存是给谁用的呢?其实就是线程,每个线程启动后,虚拟机就会为其分配一块栈内存。

  • 每个栈由多个栈帧(Frame)组成,对应着每次方法调用时所占用的内存
  • 每个线程只能有一个活动栈帧,对应着当前正在执行的那个方法
线程上下文切换(Thread Context Switch

因为以下一些原因导致 cpu 不再执行当前的线程,转而执行另一个线程的代码

  • 线程的 cpu 时间片用完
  • 垃圾回收
  • 有更高优先级的线程需要运行
  • 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时,需要由操作系统保存当前线程的状态,并恢复另一个线程的状态,Java 中对应的概念就是程序计数器(Program Counter Register),它的作用是记住下一条 jvm 指令的执行地址,是线程私有的

  • 状态包括程序计数器、虚拟机栈中每个栈帧的信息,如局部变量、操作数栈、返回地址等
  • Context Switch 频繁发生会影响性能

4.线程

4.1start与run

调用run

public static void main(String[] args) {
 Thread t1 = new Thread("t1") {
 @Override
 public void run() {
 log.debug(Thread.currentThread().getName());
 FileReader.read(Constants.MP4_FULL_PATH);
 }
 };
 t1.run();
 log.debug("do other things ...");
}

输出:

是主线程main来调用run方法,程序仍在 main 线程运行, FileReader.read() 方法调用还是同步的

19:39:14 [main] c.TestStart - main
19:39:14 [main] c.FileReader - read [1.mp4] start ...
19:39:18 [main] c.FileReader - read [1.mp4] end ... cost: 4227 ms
19:39:18 [main] c.TestStart - do other things ...

调用 start

t1.start();

输出:

19:41:30 [main] c.TestStart - do other things ...
19:41:30 [t1] c.TestStart - t1
19:41:30 [t1] c.FileReader - read [1.mp4] start ...
19:41:35 [t1] c.FileReader - read [1.mp4] end ... cost: 4542 ms

程序在 t1 线程运行, FileReader.read() 方法调用是异步的

小结:

  • 直接调用 run 是在主线程中执行了 run,没有启动新的线程
  • 使用 start 是启动新的线程,通过新的线程间接执行 run 中的代码

4.2sleep与yield

sleep

  • 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态(阻塞)
  • 其它线程可以使用 interrupt 方法打断正在睡眠的线程,这时 sleep 方法会抛出 InterruptedException
  • 睡眠结束后的线程未必会立刻得到执行(未必能立刻获得cpu使用权)
  • 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/660424.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Tomcat -- server.xml

Tomcat 部署项目 server.xml 配置 <Server port"8005" shutdown"SHUTDOWN"><Listener className"org.apache.catalina.startup.VersionLoggerListener" /><Listener className"org.apache.catalina.core.AprLifecycleListe…

区块链游戏解说:Sunflower Land 是什么

数据源&#xff1a;Sunflower Land Dashboard 作者&#xff1a;lesleyfootprint.network 什么是 Sunflower Land Sunflower Land 是基于 Polygon 网络的区块链农场游戏。玩家可以在一个充满活力和身临其境的环境中耕种、收获和交易各种农产品。Sunflower Land 使用了非同质…

Springboot 整合 Quartz(定时任务框架)

一、java 定时任务调度的实现方式 1、Timer 特点是&#xff1a;简单易用&#xff0c;但由于所有任务都是由同一个线程来调度&#xff0c;因此所有任务都是串行执行的&#xff0c;同一时间只能有一个任务在执行&#xff0c;前一个任务的延迟或异常都将会影响到之后的任务&#…

STM32存储左右互搏 QSPI总线读写FLASH W25QXX

STM32存储左右互搏 QSPI总线读写FLASH W25QXX FLASH是常用的一种非易失存储单元&#xff0c;W25QXX系列Flash有不同容量的型号&#xff0c;如W25Q64的容量为64Mbit&#xff0c;也就是8MByte。这里介绍STM32CUBEIDE开发平台HAL库Qual SPI总线操作W25Q各型号FLASH的例程。 W25Q…

python异步编程(1)——理论篇

1.理解多线程 当启动一个Python程序时&#xff0c;它会作为一个单独的进程运行在操作系统中。进程是操作系统分配资源&#xff08;如内存和处理器时间&#xff09;的基本单位。每个Python程序启动时&#xff0c;都会创建一个主线程。如果没有在代码中明确创建其他线程&#xf…

【通讯录案例-沙盒路径 Objective-C语言】

一、接下来,我们来学习“存储”的相关的一些东西, 1.打开这个“数据存储“的ppt, 打开这个ppt, 首先呢,关于存储这一块儿, 存储呢,首先,有常见的几种方式,注意啊,这个里边儿是“方式”,方式,什么意思,是表示怎么去存,有五种方式: 1)XML属性列表(plist)归档:…

C++ 11新特性之语法甜点2

概述 C 11中引入了许多简化编程工作的语法上的新特性&#xff0c;我们暂且美其名曰&#xff1a;“语法甜点”。书接上篇&#xff0c;我们继续介绍C 11中的这些“语法甜点”&#xff0c;也是第二篇关于“语法甜点”的文章。 语法甜点6&#xff1a;模板右边双括号 在C 03中&#…

AOP使用案例

//加入bean Component //指定这是一个aop类 AspectSlf4j public class AOPlogin {Autowiredlogrizhi diaoyong;//获取传递过来jwt令牌AutowiredHttpServletRequest jwtlog ;//annotation(* com.example.tlias.AOPbao.loginin // Pointcut("annotation(* com.example.tl…

VUE!!!必看

ECMAScript 6-11 ECMAScript 相关介绍 什么是 ECMA ECMA&#xff08;European Computer Manufacturers Association&#xff09;中文名称为欧洲计算机制造商协会&#xff0c;这个组织的目标是评估、开发和认可电信和计算机标准。1994 年后该组织改名为 Ecma 国际。 什么是 …

【数据结构】(三)树Tree

目录 1、基本概念 2、二叉树Binary Tree 3、树、森林与二叉树的转换 4、赫夫曼树Huffman Tree与赫夫曼编码Huffman Coding 1、基本概念 &#xff08;1&#xff09;树&#xff08;Tree&#xff09;是 n&#xff08;n ≥\geq 1&#xff09;个节点的有限集&#xff0c;n 0时称…

记elasticsearch CPU负载100%问题

记elasticsearch CPU负载100%问题 环境&#xff1a;问题表现&#xff1a;初步排查&#xff1a;日志查询hot_thread 深入查询当前elasticsearch正在运行的Task查看Task详情解决问题对导致问题的原因的几个猜测问题复现&#xff1a;导致问题的原因。json导入规则问题json导入规则…

Linux系统安全之iptables防火墙

目录 一、iptables防火墙的基本介绍 1、netfile与iptables的关系 1.1netfile 1.2iptables 1.3iptables是基于内核的防火墙&#xff0c;其中内置了raw&#xff0c;mangle&#xff0c;nat和filter四个规则表 2、iptables防火墙默认规则表&#xff0c;链结构 二、iptables的…

python实例100第50例:使用 random 模块输出一个随机数。

题目&#xff1a;输出一个随机数。 程序分析&#xff1a;使用 random 模块。 程序源代码&#xff1a; 实例 #!/usr/bin/python # -*- coding: UTF-8 -*-import random#生成 10 到 20 之间的随机数 print (random.uniform(10, 20)) 以上实例输出结果为&#xff1a; 14.4012…

HashSet 的基本操作【集合容器知识回顾 ④】

HashSet 是 Java 中的一个集合类&#xff0c;它实现了 Set 接口。Set 是一种不允许包含重复元素的集合&#xff0c;而 HashSet 则是 Set 接口的一个具体实现。因此&#xff0c;HashSet 用于存储一组唯一的元素&#xff0c;不允许重复。 HashSet 的一些特点&#xff1a; 不允许…

漏洞03-CSRF漏洞

CSRF漏洞 文章目录 CSRF CSRF

mybatis之@Table和@Column注解

背景 假如我们使用mybatis有时候会看到Table和Column注解注解&#xff0c;Table通常写着表的名字&#xff0c;Column注解写着对应数据库字段的值&#xff0c;在一开始我以为它们是用来做数据库表和实体类映射的&#xff0c;比如说通过mybatis从数据库查询&#xff0c;然后结果…

链式二叉树(1)

目录 二叉树的概念&结构 二叉树的遍历概念 手写二叉树测试 二叉树遍历实现代码 递归图解 前序遍历递归图解 中序序遍历递归图解 后续遍历递归图解 二叉树的概念&结构 二叉树是&#xff1a; 空树非空&#xff1a;根节点&#xff0c;根节点的左子树、根节点的右子…

3ASC25H216A DATX132

3ASC25H216A DATX132 3ASC25H216A DATX132 3ASC25H216A DATX132在DAQ应用中使用非隔离DC/DC电源降压模块的优势 "... 图3&#xff1a;德州仪器电源模块电感HTS性能 此外&#xff0c;我们的电源 ... 响应。 图4&#xff1a;功率模块效率和负载瞬态响应 若保持 ...…

Java设计模式-组合模式(13)

大家好,我是馆长!今天开始我们讲的是结构型模式中的组合模式。老规矩,讲解之前再次熟悉下结构型模式包含:代理模式、适配器模式、桥接模式、装饰器模式、外观模式、享元模式、组合模式,共7种设计模式。 组合模式(Composite Pattern) 定义 组合(Composite)模式:又叫…

【开源】基于Qt5的ROS1/ROS2人机交互软件(支持地图编辑/多点导航)

本项目基于Qt5开发&#xff0c;基于CMake进行构建&#xff0c;可以实现一套代码同时在ROS1/ROS2系统中使用(本项目已接入CI,保证多ROS版本/系统版本可用性) 项目地址&#xff1a; https://github.com/chengyangkj/Ros_Qt5_Gui_App 软件在编译时会自动识别环境变量中的ROS1/ROS…