02. 线程基础知识

原创已于 2022-05-30 10:22:25 修改 · 880 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java #单例模式 #开发语言

于 2021-12-14 16:16:31 首次发布

02 多线程专栏收录该内容

3 篇文章

订阅专栏

本文详细比较了Java中通过继承Thread、实现Runnable/Callable接口及使用线程池创建线程的不同方式，探讨了各自优缺点，并深入讲解了ExecutorService、ScheduledExecutorService和线程池配置参数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一创建线程的四种方式

几种方式的对比

继承Thread：

优势：编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程

劣势：线程类已经继承了Thread类，所以不能再继承其他父类

实现Runnable接口或者Callable接口

优势：还可以继续继承别的父类；多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想；其中，Callable接口可以用来进行较为复杂的计算，相当于异步计算

劣势：编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法

1.1 继承Thread类

class MyThread extends Thread {
    public void run() {
        this.setName("Mythread");
        System.out.println(this.getName() + " 正在执行");
    }
}

1.2 实现Runnable接口

public class TestRunnable {
	public static void main(String[] args) {
		SubThread2 st = new SubThread2();	// 创建SubThread2实例
		new Thread(st, "线程1").start();	// 创建并开启线程对象
		new Thread(st, "线程2").start();
	}
}
class SubThread2 implements Runnable {
	public void run() {						// 重写run()方法
		for (int i = 0; i < 4; i++) {
			if (i % 2 != 0) {
				System.out.println(Thread.
						currentThread().getName() + ":" + i);
			}
		}
	}
}

1.3 实现Callable接口

public class Test01 {
    public static void main(String[] args) {
        // 1. 获取Callable接口的实例
        Callable<Integer> r = new MyCallable();
        // 2. 将Callable接口的实例传入，构建FutureTask实例
        FutureTask<Integer> futurnTask = new FutureTask<Integer>(r);
        // 3. 调用Thread类的构造方法
        Thread t = new Thread(futurnTask);
        t.start();
//       futurnTask.cancel(false);
        //调用get方法会导致main线程（调用get方法的线程）被阻塞
        int result = futurnTask.get();
        System.out.println(result); // 1
        System.out.println("阻塞结束");
    }
}

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        Thread.sleep(5000);
        return 1;
    }
}

其中，FutureTask类实现了RunnableFuture接口，RunnableFuture接口实现了Runnable和Future接口

以下是相关的api

// 获取线程执行完后的返回结果，调用会阻塞线程，直到计算完成
V get();
// 获取结果，同样也会阻塞线程，但是如果超出了指定时间未获取到结果，将抛出超时异常
V get(long timeout, TimeUnit unit);
// 尝试取消计算（call方法）的执行，如果mayInterruptIfRunning为true，那么直接中断；中断成功返回true
boolean cancel(boolean mayInterruptIfRunning);
// 如果任务在完成前被取消，则返回true
boolean isCancelled();
// 如果任务结束，只要停止执行了，就返回true
boolean isDone();

// 构造一个FutureTask对象，用于传入Thread的构造方法中，开启线程
FutureTask(Callable<V> callable);
// 构造一个FutureTask对象，用于传入Thread的构造方法中，开启线程
FutureTask(Runnable runnable, V result);

1.4 使用线程池

接口关系

Executor >> ExecutorService >> SchedulExecutorService

Executors是一个工具类，用来获取线程池的实例，类似Collections

获取线程池实例的底层实现：new ThreadPoolExecutor();

结构关系图
在这里插入图片描述

1.4.1 创建线程池

执行器类Executors有很多静态方法，用来构造线程池

以下是相关的Api

// 必要时创建新的线程，空的线程会被保存60秒
static ExecutorService newCachedThreadPool();
// 创建一个有固定大小的线程池，线程会被一直保留
static ExecutorService newFixedThreadPool(int nThreads);
// 创建一个固定大小的线程池，会调度执行任务
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize);
// 创建只有一个线程的线程池，会顺序的执行所提交的任务
static ExecutorService newSingleThreadExecutor();
// 创建只有一个线程的线程池，会顺序的执行所提交的任务，会调度执行任务
static ScheduledExecutorService newSingleThreadScheduledExecutor();
// 一种适合fork-join人物的线程池，其中复杂的任务会被拆分为简单的任务，空闲线程会觅取较简单的任务
static ExecutorService newWorkStealingPool();

// 自定义线程池，调用ThreadPoolExectuor()构造方法即可
ThreadPoolExecutor myThreadPool = new ThreadPoolExectuor(..param);

1.4.2 创建线程池的七个重要参数

public ThreadPoolExecutor{
    int corePoolSize, // 核心线程数量
    int maximumPoolSize, // 最大线程数（核心线程数 + 临时线程数）
    long keepAliveTime, // 临时线程的最大空闲时间，超出即销毁
    TimeUnit unit, // 时间单位（针对临时线程）
    BlockingQueue<Runnable> workQueue, // 任务队列
    ThreadFactory threadFactory, // 线程工厂（可以为线程起名字），线程池中的线程默认名称为pool-m-thread-n
    RejectedExecutionHandler handler // 拒绝策略
}

1.4.3 ExecutorService接口相关Api

// 当任务队列中的所有任务执行完毕后，销毁线程池，不允许有新的任务提交；正在执行的任务不受影响继续执行，shutdown之后提交的任务会抛出RejectedExecutionException
void shutdown();
// 停止正在执行任务，如果任务抛出InterruptedException异常（如wait、sleep、join）则抛出异常后立刻停止，如果未抛出异常则执行完毕后再停止；暂停处理正在等待的任务，返回等待的任务的列表
List<Runnable> shutdownNow();
// 线程池是否被中断
boolean isShutdown();
// 提交带返回值的任务，返回一个表示该人物的Future对象
<T> Future<T> submit(Callable<T> task);
// 提交 Runnable 任务，并返回一个表示该任务的 Future 对象
Future<?> submit(Runnable task);
// 提交 Runnable 任务，并返回一个表示该任务的 Future 对象
<T> Future<T> submit(Runnable task, T result);

// Executor接口中有execute方法，可以用来提交Runnable任务
void execute(Runnable command);

其他方法

// 提交 tasks 中所有任务
<T> List<Future<T>> invokeA11(Collection<? extends Callable<T>> tasks) throws InterruptedException;
// 提交tasks 中所有任务，带超时时间
<T> List<Future<T>> invokeA11(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)throws InterruptedException;
// 提交tasks中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消
<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
// 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消，带超时时间
<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;

1.4.4 ScheduledExecutorService接口

该接口继承自ExecutorService接口，具备了延时执行或者定期执行的能力，该接口Api如下

// 延迟时间是delay，延时后执行callable任务
<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);
// 延迟时间是delay，延时后执行command任务
ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);
// 定时执行，第一次执行是延迟initialDelay后，开始执行后period后再执行
ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);
// 定时执行，第一次执行是延迟initialDelay后，执行完后延迟delay后再次执行，与上一个方法的差异是一个是固定周期，一个是固定每次执行完过后多久
ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);

1.4.5 线程池的拒绝策略

当一个任务被添加到线程池的时候被拒绝的话会有以下两种情况：1. 线程池异常关闭；2. 待处理的任务数量超出了等待队列的最大容量也就是提交的线程的数量超出了线程池的最大处理能力

java中内置了四种拒绝策略，分别是AbortPolicy、CallerRunsPolicy、DiscardOldestPolicy 、DiscardPolicy

// RejectExecutionHandler源码
public interface RejectedExecutionHandler {
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}
// AbortPolicy使中止策略，是默认的拒绝策略，当无法处理时抛出拒绝异常RejectedExecutionException，不再执行该任务
public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }
    //重写的方法
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                        " rejected from " + e.toString());
    }
}
// CallerRunsPolicy，回调上层线程去执行该任务，如果线程池没有shutdown，则调用 execute 函数的上层线程(例如main线程)去执行被拒绝的任务
public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}
// DiscardOldestPolicy抛弃最老的策略，把任务队列中最早放入的任务抛弃，尝试再次提交新的任务
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}
// DiscardPolicy直接抛弃该任务
public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        //没有做处理表示直接丢弃这个任务
    }
}

// 自定义拒绝策略
class myPolicy implements RejectExecutionHandler{
	 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
       System.out.print("这是我自己的拒绝策略")
    }  
}

1.4.6 线程工厂

当构建线程池的时候，可以使用自定义线程工厂，用来改变线程的属性和一些行为，比如修改线程的名字，打印线程等

ThreadFactory接口源码

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

创建自己的线程工厂，继承ThreadFactory接口
重写newThread（）方法

自己的线程工厂

public class MyThreadFactory implements ThreadFactory{
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        // 1. 打印日志
        System.out.println("当前时间是： " + new SimpleDateFormat().format(new Date()));
        // 2. 修改线程的名字
        t.setName("这是我自己的线程" + t.getId());
        System.out.println("线程： " + t.getName());
        return t;
    }
}

1.4.7 线程池常用方法

1.4.7.1 线程池结束状态判断

// 是否停工；调用了shutdown和shutdownNow之后，即使还有任务在执行也会返回true
boolean isShutdown();
// 是否停止；只有线程池被关闭且任务全部执行完毕后，才会返回true
boolean isTerminated();

1.4.7.2 核心线程预启动

默认情况下，线程池中的核心线程只有在有任务提交的时候才会创建，为了提高线程的效率，可以将提交到线程池中的核心线程预先创建，省去创建的开销

// 调用ThreadPoolExecutor类中的以下两个方法
// 启动一个核心线程
boolean prestartCoreThread();
// 启动所有的核心线程，数量是创建线程池时指定的核心线程数
boolean prestartAllCoreThreads();

1.4.7.3 线程和线程池切面编程

可以实现自己的线程池，重写beforeExecute()、afterExecute()、 terminate()方法，再线程执行前、执行后、关闭线程池时执行某段代码

public class MyThreadPoolExecutor extends ThreadPoolExecutor {

    public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    @Override
    public void beforeExecute(Thread t, Runnable runnable) {
        System.out.println("线程开始执行了");
    }

    @Override
    public void afterExecute(Runnable r, Throwable t) {
        System.out.println("线程执行结束");
    }

    public static void main(String[] args) {
        ThreadPoolExecutor tp = new MyThreadPoolExecutor(1, 1, 10, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());
        tp.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程执行中");
            }
        });
    }
}

1.4.7.4 移除线程池中的任务

可以调用ThreadPoolExecutor中的remove()方法，移除满足条件的任务

正在执行中的任务不可以被移除
execute方法提交的，未执行的任务可以被移除
submit方法提交的，未运行的任务不可以被移除

1.4.7.5 获取线程池的各项数据

调用ThreadPoolExecutor类中的以下方法，可以获取线程池中的一些属性

返回核心线程数：getCorePoolSize
返回当前线程池中的线程数：getPoolSize
返回最大允许的线程数：getMaximumPoolSize
返回池中同时存在的最大线程数：getLargestPoolSize
返回预定执行的任务总和：getTaskCount
返回当前线程池已经完成的任务数：getCompletedTaskCount
返回正在执行任务的线程的大致数目：getActiveCount
返回线程池空闲时间：getKeepAliveTime

据

调用ThreadPoolExecutor类中的以下方法，可以获取线程池中的一些属性

返回核心线程数：getCorePoolSize
返回当前线程池中的线程数：getPoolSize
返回最大允许的线程数：getMaximumPoolSize
返回池中同时存在的最大线程数：getLargestPoolSize
返回预定执行的任务总和：getTaskCount
返回当前线程池已经完成的任务数：getCompletedTaskCount
返回正在执行任务的线程的大致数目：getActiveCount
返回线程池空闲时间：getKeepAliveTime