线程的创建方式-CSDN博客

本文链接：https://blog.csdn.net/m0_46502752/article/details/126819588

1.1 什么是程序？

程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，可以理解为程序是包含静态代码的文件。例如：浏览器软件、音乐播放器软件等软件的安装目录和文件。

1.2 什么是进程？

进程是程序的一次执行过程，是系统运行程序的基本单位。在Windows系统中，每一个正在执行的exe文件或后台服务，都是一个进程，由操作系统统一管理并分配资源，因此进程是动态的。例如：正在运行中的浏览器就是一个进程，正在运行中的音乐播放器是另一个进程，同理，正在运行中的QQ和WPS等都是进程。

操作系统运行一个程序，即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如 CPU时间，内存空间，文件，输入输出设备的使用权等。

1.3 什么是线程？

某些进程内部还需要同时执行多个子任务。例如，我们在使用WPS时，WPS可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行自动保存和上传云文档，我们把子任务称为线程。线程是进程划分成的更小的运行单位。

进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个主线程。

┌──────────┐
│Process │
│┌────────┐│
┌──────────┐││ Thread ││┌──────────┐
│Process ││└────────┘││Process │
│┌────────┐││┌────────┐││┌────────┐│
┌──────────┐││ Thread ││││ Thread ││││ Thread ││
│Process ││└────────┘││└────────┘││└────────┘│
│┌────────┐││┌────────┐││┌────────┐││┌────────┐│
││ Thread ││││ Thread ││││ Thread ││││ Thread ││
│└────────┘││└────────┘││└────────┘││└────────┘│
└──────────┘└──────────┘└──────────┘└──────────┘┌──────────────────────────────────────────────┐
│ Operating System │
└──────────────────────────────────────────────┘

线程是一个比进程更小的执行单位(cpu的更小执行单位)。一个进程在其执行的过程中可以产生多个线程。与进程不同的是，同类的多个线程共享一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小的多。

1.4进程与线程的区别

根本区别:进程时操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位。

资源开销:每个进程都有独立的代码副本和数据空间，进程之间的切换，资源开销较大；线程可以看做轻量级的进程，每个线程都有独立的运行栈和程序计数器，线程之间切换，资源开销小。

包含关系:一个进程包含有多个线程，在执行过程，线程的执行不是线性串行的，而是多条线程并行共同完成；

内存分配:同一个进程内的所有进程共享本进程的内存空间或资源；进程之间的内存空间和资源相互独立；

影响关系:一个进程崩溃后，在保护模式下不会对其他进程产生影响；一个进程崩溃，会导致整个进程退出。所以多进程要比多线程健壮；

执行过程:每个独立的进程有程序运行的入口和程序出口。但是线程不能独立执行，必须依存在应用程序(进程)中，由应用程序提供多个线程执行控制.

JVM进程

JVM进程的内存区域分配

- JVM进程启动时，自动创建Heap（堆区）和 Metaspace（元空间，JDK1.8以前叫Method Area方法区）；
- 多个线程共享JVM进程的Heap（堆区）和Metaspace（元空间）资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈。系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，因此，线程也被称为轻量级进程。

JVM进程由哪些线程组成？

public class Main {

public static void main(String[] args) {

// 获取 Java 线程管理对象 ThreadMXBean

ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();



// 不需要获取的锁监视器 lockedMonitor 和 synchronizer 信息

// 仅获取线程和线程信息

ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);



// 遍历线程信息，仅打印线程 ID 和线程名称信息

for (ThreadInfo threadInfo : threadInfos) {

System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());

}

}

}

线程的创建方式4种方式

方式一：继承 `java.lang.Thread` 类（线程子类）

// 线程子类
public class SubThread extends Thread {
       public void run() {
           for (int i = 0; i < 10000; i++) {
               System.out.println("子线程" + i + " ");
           }
       }
}

// 主线程main
public class MultiThread {
       public static void main(String[] args) {
            //创建并启动子线程
           SubThread thd = new SubThread();
           thd.start();
           
           //主线程继续同时向下执行
           for (int i = 0; i < 10000; i++) {
               System.out.println("主线程" + i + " ");
           }
       }
}

方式二：实现 java.lang.Runnable 接口（线程执行类）

// 线程执行类
public class SubThread implements Runnable {
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("子线程" + i + " ");
        }
    }
}

// 主线程 main
public class MultiThread {
    public static void main(String[] args) {
        //创建并启动子线程
        Thread t = new Thread(new SubThread());
        t.start(); 

        //主线程继续同时向下执行
        for (int i = 0; i < 10000; i++) {
            System.out.println("主线程" + i + " ");
        }
    }
}

两种方式对比：
1、继承Thread类
子类继承Thread类具有多线程能力
启动线程：子类对象.start()
不建议使用：避免OOP单继承局限性

2、实现Runnable接口
实现接口Runnable具有多线程能力
启动线程：传入目标对象+Thread对象.start()
推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多线程使用

方式三：实现 `java.util.concurrent.Callable` 接口，允许子线程返回结果、抛出异常

// 实现子线程
public class SubThread implements Callable<Integer>{
    private int begin,end;
    public SubThread(int begin,int end){
        this.begin = begin;
        this.end = end;
    }
    @Override
    public Integer call() throws Exception {
        int result = 0;
        for(int i=begin;i<=end;i++){
            result+=i;
        }
        return result;
      }
}

子线程创建并启动

// 子线程封装为FutureTask对象,计算1-100的累加和
SubThread subThread1 = new SubThread(1,100);
FutureTask<Integer> task1 = new FutureTask<>(subThread1);

// 子线程封装为FutureTask对象,计算101-200的累加和
SubThread subThread2 = new SubThread(101,200);
FutureTask<Integer> task2 = new FutureTask<>(subThread2);

// 分别启动两个子线程
new Thread(task1).start();
new Thread(task2).start();

// 分别获取两个子线程的计算结果
int sum1 = task1.get();
int sum2 = task2.get();

// 汇总计算结果
int total = sum1 + sum2;

优点：
1、可以定义返回值
2、可以抛出异常

方式四：线程池

线程池，按照配置参数（核心线程数、最大线程数等）创建并管理若干线程对象。程序中如果需要使用线程，将一个执行任务传给线程池，线程池就会使用一个空闲状态的线程来执行这个任务。执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。使用线程池可以很好地提高性能。

好处：

1、提高响应速度（减少了创建新线程的时间）
2、降低资源消耗（重复利用线程池中线程，不需要每次创建）
3、便于线程管理

在Java标准库提供了如下几个类或接口，来操作并使用线程池：

ExecutorService接口：来进行管理操作线程池；
Executors类：用于创建线程池的工具类；
ThreadPoolExecutor及其子类：线程池；

// 创建固定大小的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
while (true) {
    // 提交多个执行任务至线程池，并执行
    threadPool.execute(new Runnable() {
        @Override
        public void run() {
             System.out.println("当前运行的线程名为： " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    });
}