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

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.同步和异步

同步和异步的概念

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

同步等待

异步等待

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表达式来简化写法

​

// 创建任务对象
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（密码）

例子：

3.2 线程运行原理

3.2.1.虚拟机栈与栈帧

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

3.2.2.线程上下文切换（Thread Context Switch）

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

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

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

3.3 Thread的常见方法

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

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