黑马程序员并发编程笔记(一)

1.聊聊线程和进程

1.1.进程和线程的概念

什么是进程?

可以理解为,进程就是存储在静态资源(磁盘)里的程序(指令和数据)运行时的一种状态,通俗的理解,进程就是运行时的程序。

注释:程序由数据和指令组成,这些指令要读写,就必须把指令加载到cpu,数据加载到内存 。进程就是来加载指令,管理内存,管理io的

注意:内存一般指的是运行内存,因为小时候不准确的概念,我们常常将内存和磁盘存储相关联,但二者不相同。

当一个程序被调用时,它就作为一个进程,从磁盘加载到内存之中。一个程序可以有多个进程(记事本)也可以只有一个进程(网易云音乐)。

线程的简单概述

一个进程中可以分配多个线程。

线程是一个指令流,将指令流中的一条条指令交给cpu运行。

java中线程是最小的调度,进程时资源分配的最小单位。在windows中不活动,而作为线程的容器。

对比

  • 进程是独立的,而线程存在于进程中,是它的一个子集。
  • 进程拥有共享的资源,如内存空间等,供其内部的线程共享·进程间通信较为复杂
  • 同一台计算机的进程通信称为IPC ( lnter-process communication )
    不同计算机之间的进程通信,需要通过网络,并遵守共同的协议,例如HTTP
  • 线程通信相对简单,因为它们共享进程内的内存,一个例子是多个线程可以访问同一个共享变量·线程更轻量,线程上下文切换成本一般上要比进程上下文切换低

关于上下文切换

简单来说就是把不用的进程/线程 kill掉,防止它们占用不必要的内存。

2.并发和并行

2.1.并发

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

一般会将这种 线程轮流使用 CPU 的做法称为并发, concurrent

通俗理解:一个核心轮流调用各个线程。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fjCRK2Wy-1642763425871)(https://static01.imgkr.com/temp/5d859f6d95c343e89689cdce92d8fa44.png)]

2.2.并行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SoE125yS-1642763425872)(https://static01.imgkr.com/temp/b5d0319a9e174b9da93062ab047b64ea.png)]

通俗来讲:就是多个核心在一个时间里执行不同的线程。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QOb920Rq-1642763425873)(https://static01.imgkr.com/temp/11a9e64b03c84d4abac13191dae6ad3a.png)]

2.3.同步和异步

同步和异步的概念

以调用方的角度讲,如果需要等待结果返回才能继续运行的话就是同步,如果不需要等待就是异步

同步等待

QQ截图20220121094639

异步等待

QQ截图20220121094648

1) 设计

多线程可以使方法的执行变成异步的,比如说读取磁盘文件时,假设读取操作花费了5秒,如果没有线程的调度机制,这么cpu只能等5秒,啥都不能做。

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

3.java进程的基本操作

3.1.创建进程

方法一,直接使用 Thread
// 构造方法的参数是给线程指定名字,,推荐给线程起个名字(用setName()也可以)
Thread t1 = new Thread("t1") {
 @Override
 // run 方法内实现了要执行的任务
 public void run() {
 log.debug("hello");
 }
};
t1.start();
方法二,使用 Runnable 配合 Thread

把【线程】和【任务】(要执行的代码)分开,Thread 代表线程,Runnable 可运行的任务(线程要执行的代码)Test2.java

// 创建任务对象
Runnable task2 = new Runnable() {
 @Override
 public void run() {
 log.debug("hello");
 }
};
// 参数1 是任务对象; 参数2 是线程名字,推荐给线程起个名字
Thread t2 = new Thread(task2, "t2");
t2.start();

1.8后用lambda表达式来简化写法

QQ截图20220121101957

// 创建任务对象
Runnable task2 = () -> log.debug("hello");
// 参数1 是任务对象; 参数2 是线程名字,推荐
Thread t2 = neaw Thread(task2, "t2");
t2.start();

也可以更简略一点

// 参数1 是任务对象; 参数2 是线程名字,推荐
Thread t2 = neaw Thread(() -> log.debug("hello"), "t2");
t2.start();

idea里 lamba表达式简化快捷键: alt +enter

小结

方法1 是把线程和任务合并在了一起,方法2 是把线程和任务分开了,用 Runnable 更容易与线程池等高级 API 配合,用 Runnable 让任务类脱离了 Thread 继承体系,更灵活。通过查看源码可以发现,方法二其实到底还是通过方法一执行的!

需要注意的是:

  • 如果直接运行Thread的run()方法,则是主线程调用
方法三,FutureTask 配合 Thread

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

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 实现多线程的第三种方法可以返回数据也可以抛出异常,返回的数据需要用get接收
        FutureTask futureTask = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                log.debug("多线程任务");
                Thread.sleep(100);
                return 100;
            }
        });
        
  
        new Thread(futureTask,"我的名字").start();
        log.debug("主线程");
        //{}表示占位,实际值是后买你的参数,获取结果。必要时可以通过get方法获取执行结果,该方法会阻塞直到任务返回结果。
        log.debug("{}",futureTask.get());
    }

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future提供了三种功能:

  1. 判断任务是否完成;
  2. 能够中断任务;
  3. 能够获取任务执行结果。

3.3 查看进程线程的方法

windows

任务管理器可以查看进程和线程数,也可以用来杀死进程

tasklist 查看进程

taskkill 杀死进程

tasklist | findstr java 查看所有的java线程

linux

ps -fe 查看所有进程

ps -fT -p <PID> 查看某个进程(PID)的所有线程

kill 杀死进程

top 按大写 H 切换是否显示线程

top -H -p <PID> 查看某个进程(PID)的所有线程

ps -fe | grep java 查看所有的java进程

Java

jps 命令查看所有 Java 进程

jstack <PID> 查看某个 Java 进程(PID)的所有线程状态

jconsole 来查看某个 Java 进程中线程的运行情况(图形界面)

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类

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

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

复制 jmxremote.password 文件

修改 jmxremote.password 和 jmxremote.access 文件的权限为 600 即文件所有者可读写

连接时填入 controlRole(用户名),R&D(密码)

例子:

QQ截图20220121153824

QQ截图20220121153952

3.2 线程运行原理

3.2.1.虚拟机栈与栈帧

QQ截图20220121155442

拟机栈描述的是Java方法执行的内存模型:每个方法被执行的时候都会同时创建一个栈帧(stack frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息,是属于线程的私有的。当java中使用多线程时,每个线程都会维护它自己的栈帧!每个线程只能有一个活动栈帧,对应着当前正在执行的那个方法

3.2.2.线程上下文切换(Thread Context Switch)

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

  • 线程的 cpu 时间片用完(每个线程轮流执行,看前面并行的概念)
  • 垃圾回收
  • 有更高优先级的线程需要运行
  • 线程自己调用了 sleepyieldwaitjoinparksynchronizedlock 等方法

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

3.3 Thread的常见方法

20200306114615-258720

QQ截图20220121184804

3.3.1 start 与 run

调用start
    public static void main(String[] args) {
        Thread thread = new Thread(){
          @Override
          public void run(){
              log.debug("我是一个新建的线程正在运行中");
              FileReader.read(fileName);
          }
        };
        thread.setName("新建线程");
        thread.start();
        log.debug("主线程");
    }

输出:程序在 t1 线程运行, run()方法里面内容的调用是异步的 Test4.java

11:59:40.711 [main] DEBUG com.concurrent.test.Test4 - 主线程
11:59:40.711 [新建线程] DEBUG com.concurrent.test.Test4 - 我是一个新建的线程正在运行中
11:59:40.732 [新建线程] DEBUG com.concurrent.test.FileReader - read [test] start ...
11:59:40.735 [新建线程] DEBUG com.concurrent.test.FileReader - read [test] end ... cost: 3 ms
调用run

将上面代码的thread.start();改为 thread.run();输出结果如下:程序仍在 main 线程运行, run()方法里面内容的调用还是同步的

12:03:46.711 [main] DEBUG com.concurrent.test.Test4 - 我是一个新建的线程正在运行中
12:03:46.727 [main] DEBUG com.concurrent.test.FileReader - read [test] start ...
12:03:46.729 [main] DEBUG com.concurrent.test.FileReader - read [test] end ... cost: 2 ms
12:03:46.730 [main] DEBUG com.concurrent.test.Test4 - 主线程
小结

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

3.3.2 sleep 与 yield

sleep

QQ截图20220121161549

  1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态(阻塞)
  2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程,那么被打断的线程这时就会抛出 InterruptedException异常【注意:这里打断的是正在休眠的线程,而不是其它状态的线程】
  3. 睡眠结束后的线程未必会立刻得到执行(需要分配到cpu时间片)
  4. 建议用 TimeUnit 的 sleep() 代替 Thread 的 sleep()来获得更好的可读性
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值