2.进程与线程

2.进程与线程

2.1 进程与线程

进程：

• 程序由指令和数据组成，指令要执行，数据要读写，就需要将指令加载到cpu，数据加载到内存，进程就是用来加载指令、管理IO、管理内存的
• 当一个程序被执行，从磁盘加载代码到内存，这时就开启了一个进程
• 进程可以视为程序的实例，大部分程序可以同时运行多个实例。

线程：

• 一个进程有一个或多个线程
• 一个线程就是一个指令流，将指令流中的一条条指令交给cpu执行
• 线程是java调度的最小单位，进程作为资源分配的最小单位。

两者对比：

• 进程基本上是相互独立的，而线程存在于进程内，是进程的一个子集

• 进程拥有共享的资源，如内存空间，供内部的线程共享

• 进程之间的通信比线程更复杂

• • 同一台计算机不同进程之间的通信称为IPC
  • 不同计算机之间的通信需要遵守同样的网络协议，如HTTP

• 线程通信相对简单，因为它们共享进程内的内存

• 线程更轻量，线程上下文切换成本比进程上下文切换低

2.2 并行与并发

并发：

在同一时间内，单核cpu同时执行多个线程

并行：

在同一时间，多核cpu一起执行多个线程

2.3 应用

应用之异步调用（案例1）

从调用的角度来讲，如果

• 不需要等待结果返回，才能执行的是异步

同步等待

/**
 * 同步等待
 * @author xc
 * @date 2023/4/30 15:28
 */

@Slf4j
public class Sync2_3 {
    
    
    public static void main(String[] args) {
    
    
        FileReader.read("D:\\学习\\随便玩玩\\wxPush\\DEPLOY.md");
        log.debug("do other things ...");
    }
}

可以看到需要文件读完后才执行其它事情

• 需要等待结果返回，才能执行的是同步

异步不要等待

/**
 * 异步不等待
 * @author xc
 * @date 2023/4/30 15:35
 */
@Slf4j
public class Async2_3 {
    
    
    public static void main(String[] args) {
    
    
        new Thread(()-> FileReader.read("D:\\学习\\随便玩玩\\wxPush\\DEPLOY.md")).start();
        log.debug("do other things ...");
    }
}

可以看到不要等待文件读完就可以做其它事情

1）设计

多线程可以让方法变为异步的，比如说读取磁盘文件时，假如花了30分钟，如果没有线程调度机制，那这30分钟cpu什么都做不了，其它代码都要暂停

2）结论

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

应用之提高效率（案例1）

充分利用多核cpu的优势，提高运行效率

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

• 如果时串行需要花费31 ms
• 如果时并行需要花费3次计算中最长的时间+1ms即可，也就是12ms

设计代码

package com.itcast;

import org.openjdk.jmh.annotations.*;

import java.util.Arrays;
import java.util.concurrent.FutureTask;

@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();
    }
}

运行结果，可以看到并行相较于串行性能有很大提升

总结

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

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

• • 有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序运行效率。但不是所有计算任务都能拆分
  • 也不是所有任务都需要拆分，人物的目的如果不同，谈拆分和效率没啥意义

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

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

• • 有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序运行效率。但不是所有计算任务都能拆分
  • 也不是所有任务都需要拆分，人物的目的如果不同，谈拆分和效率没啥意义

• IO操作不占用cpu，但是我们拷贝使用的是阻塞IO，相当于不使用cpu还需要等待IO结束，没能充分利用线程，后面才有了非阻塞IO和异步IO