java-新手笔记(线程篇)

线程

线程是操作系统能进行算法调度的最小单位，它被包含在进程中，是进程中的实际操作单位。程序员可以通过线程进行多处理器编程，使用多线程对运算密集型任务提速.

线程的生命周期与状态：线程具有新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）五种状态。

新建状态是指当程序使用new关键字创建了一个线程之后的状态；

就绪状态是线程等待CPU分配时间片以便运行的状态；

运行状态是线程占用CPU并执行相应代码的状态；

阻塞状态是线程因为某种原因（如等待I/O操作完成）而暂停执行的状态；

死亡状态则是线程执行完毕后的状态。

模版

这边是模拟一个线程从新建到结束的过程

1.新建一个线程对象 用匿名函数(Lambda表达式)用于封装线程运行执行的任务

2.启动线程任务 这边是 start()调用来启动线程任务

3.启动任务,会运行任务来执行相关代码

4.这边暂时没考虑阻塞任务(阻塞任务较复杂)

5.一旦线程执行完成就会死亡用 isAlive 判断是否存在

public class UsingThread {
    public static void main(String[] args) {
        //新建一个状态 .创建一个线程对象,但线程还没有开始执行
        Thread thread = new Thread(() -> {
            try {
                //线程运行,执行线程任务
                System.out.println("Thread is running ..");
               //线程休眠,模拟长时间运行
                Thread.sleep(2000);
                System.out.println("Thread is waking up ...");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        });
//线程此时处于新建状态
        System.out.println("Thread is New state.");
        //就绪状态,启动线程
        thread.start();
        //一旦线程调用start方法,它就进行就绪状态,等待CPU调用执行
        System.out.println("Thread is in RUNNABLE state.");
        //主线程休眠一段时间,以便观察上面创建的线程的状态和执行情况
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        if (!thread.isAlive()){
            System.out.println("Thread is in DEAD state. ");
        }else {
            System.out.println("Thread is still alive.");
        }


    }
}

 

线程池

线程池（ThreadPool）是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的ThreadFactory创建一个新线程。

线程池的主要目的是提供一种有效的方法来控制执行的线程数量，以便可以复用线程资源，避免频繁地创建和销毁线程，从而降低系统开销。

线程池通常具有以下几个关键组成部分：

1. 核心线程数：线程池中始终保持的线程数量，即使这些线程处于空闲状态。

2. 最大线程数：线程池中允许的最大线程数量。当工作队列已满，且当前线程数小于最大线程数时，线程池会创建新的线程来处理任务。

3. 工作队列：用于存放待处理的任务。当线程池中的线程都在忙时，新提交的任务会被放入队列中等待。

4. 线程工厂：用于创建新线程的工厂，可以自定义线程的创建过程，例如设置线程名、线程优先级等。

5. 拒绝策略：当线程池无法处理新任务时（例如，队列已满且线程数已达到最大），所采取的策略。常见的拒绝策略有：直接抛出异常、调用执行任务的run方法（但不保证顺序）、丢弃队列中最旧的任务或丢弃当前任务。

6. 线程生命周期管理：线程池负责管理线程的创建、调度、销毁等生命周期。

7. 线程池状态：线程池具有不同的状态，如RUNNING（接受新任务，并处理队列中的任务）、SHUTDOWN（不接受新任务，但处理队列中的任务）、STOP（不接受新任务，不处理队列中的任务，并中断正在处理的任务）、TIDYING（所有任务都终止了，workerCount 为0，线程转换为 TIDYING 状态并将执行 terminated() 钩子方法）、TERMINATED（terminated() 方法已执行完毕）。

这边 Java 的线程池来并发地执行多个任务，并如何等待这些任务完成或超时后关闭线程池

1.这边用构造函数封装一个成员变量l用于传递给实体类

2.重写run()方法,这个是由Runnable接口中定义的方法

3.新建一个公共类 用 ExecutorService固定一个线程池,超出范围时候就会等待CPU资源释放再使用

4.创建完线程之后,就用executorService.shutdown(),关闭线程池

4.executorService.awaitTermination 方法来等待所有任务完成或等待指定的超时时间,如果没有完成就用executorService.shutdown()强制停止程序

package day02;
import java.util.concurrent.*;
//写一个类接入接口runnable
class RunnableJob implements Runnable {
    private final String name;//私有成员变量

    public RunnableJob(String name) {
        this.name = name;//构造一个函数将name成员变量传递给实体类例子
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ": " + name + " is running.");
//重写一个run()方法
        try {
            // 模拟耗时任务
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println(Thread.currentThread().getName() + ": " + name + " is done.");
    }
}
//创建一个公共类,用于装线程池
public class usingThreadPoolExcuator {

    public static void main(String[] args) {
        // 创建一个固定大小的线程池，包含3个线程
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 提交任务给线程池执行
        executorService.execute(new RunnableJob("Job1"));
        executorService.execute(new RunnableJob("Job2"));
        executorService.execute(new RunnableJob("Job3"));
        executorService.execute(new RunnableJob("Job4")); // 这个任务将等待线程变得可用

        // 关闭线程池，不再接受新任务
        executorService.shutdown();

        try {
            // 等待所有任务完成，或者超时
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                // 如果没有在规定时间内完成，则强制关闭线程池
                executorService.shutdownNow();
            }
// executorService.awaitTermination 方法来等待所有任务完成或等待指定的超时时间（这里是 60 秒）。
如果在这个时间内所有任务都完成了，那么程序会继续执行。否则，或者如果在等待期间线程被中断，它会调用 executorService.shutdownNow() 来尝试停止所有正在执行的任务并关闭线程池。
        } catch (InterruptedException e) {
            // 如果等待过程中被中断，则也强制关闭线程池
            executorService.shutdownNow();
        }
    }

 运行图