多线程的前置知识点

最新推荐文章于 2024-09-08 11:09:43 发布
最新推荐文章于 2024-09-08 11:09:43 发布
阅读量342 收藏
点赞数 1
分类专栏： Java并发 文章标签： java 多线程 并发编程 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44209336/article/details/114229462
版权

多线程的前置知识点

文章目录

1 线程的几种状态

  1. new 尚未启动的线程处于此状态 是指还没调用Thread实例的start()方法。

    Thread thread = new Thread(()->{});
System.out.println(thread.getState()); // 输出 NEW

  2. runnable 在Java虚拟机中执行的线程处于此状态。

  3. blocked 被阻塞等待监视器锁定的线程处于此状态。

  4. waiting 正在等待另一个线程执行特定动作的线程处于此状态。

    调用如下3种方法会使线程进入等待状态：

    • Object.wait()：使当前线程处于等待状态直到另⼀个线程唤醒它；
    • Thread.join()：等待线程执行完毕，底层调用的是Object实例的wait⽅法；
    • LockSupport.park()：除非获得调用许可，否则禁用当前线程进⾏线程调度。

  5. timed_waiting 超时等待状态。线程等待⼀个具体的时间，时间到后会被⾃动唤醒。

    调用如下方法会使线程进入超时等待状态：

    • Thread.sleep(long millis)：使当前线程睡眠指定时间；

    • Object.wait(long timeout)：线程休眠指定时间，等待期间可以通过

      notify()/notifyAll()唤醒；

    • Thread.join(long millis)：等待当前线程最多执⾏millis毫秒，如果millis为0，则

      会⼀直执⾏；

    • LockSupport.parkNanos(long nanos)： 除⾮获得调⽤许可，否则禁止当前线

      程进⾏线程调度指定时间；

    • LockSupport.parkUntil(long deadline)：同上，也是禁⽌线程进⾏调度指定时

      间。

  6. terminated 终⽌状态。此时线程已执⾏完毕。

线程状态转换图

在这里插入图片描述

关于start()的两个引申问题

  1. 反复调用同一个线程的start()的方法是否可行？
  2. 假如一个线程执行完毕（此时处于terminated状态），再次调用这个线程的start()是否可行？

先来看看start()的源码：

public synchronized void start() {
     if (threadStatus != 0)
     throw new IllegalThreadStateException();
     group.add(this);
     boolean started = false;
     try {
         start0();
         started = true;
     } finally {
         try {
             if (!started) {
            	 group.threadStartFailed(this);
             }
         } catch (Throwable ignore) {
         }
     }
}

我们可以看到，在start()内部，这⾥有⼀个threadStatus的变量。如果它不等于0， 调⽤start()是会直接抛出异常的。

我们可以通过debug的方式看一下：

   public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("测试start方法");
        }, "a");
        thread.start();
        thread.start();
    }

我是在start()⽅法内部的最开始打的断点，打断点看到的结果：

  • 第⼀次调⽤时threadStatus的值是0。
  • 第⼆次调⽤时threadStatus的值不为0。

查看当前线程状态的源码：

// Thread.getState()方法源码  
public State getState() {
        // get current thread state
        return sun.misc.VM.toThreadState(threadStatus);
    }

// sun.misc.VM 源码
  public static State toThreadState(int var0) {
        if ((var0 & 4) != 0) {
            return State.RUNNABLE;
        } else if ((var0 & 1024) != 0) {
            return State.BLOCKED;
        } else if ((var0 & 16) != 0) {
            return State.WAITING;
        } else if ((var0 & 32) != 0) {
            return State.TIMED_WAITING;
        } else if ((var0 & 2) != 0) {
            return State.TERMINATED;
        } else {
            return (var0 & 1) == 0 ? State.NEW : State.RUNNABLE;
        }
    }

结合上面的源码可以得到两个问题的结果：

两个问题的答案都是不可行的，在调用一次start()之后，threadStatus的值会改变（threadStatus!=0),此时再次调用start()方法会抛出IllegalThreadStateException异常。

2 三种线程初始化方法

  1. 继承Thread类、重写run方法

    class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("继承Thread类");
    }
}

public class CreateThread {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

  2. 实现Runnbale接口，重写run方法

    class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println("实现Runnable接口");
    }
}

public class CreateThread {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        thread.start();
    }
}

  3. 通过Callable和FutureTask创建线程

    class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("通过Callable创建线程");
        return 1;
    }
}

public class CreateThread {
    public static void main(String[] args) {
        Callable<Integer> callable = new MyThread();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
    }
}

  4. 区别

    • Thread有单继承的局限性，若一个类继承线程Thread就不能继承其他类。

    • Runnable是接口，可以多实现，解决了单继承的问题，不过没有返回值。

    • Callable是接口，线程运行完后会有返回值，是泛型的，可以自己指定。

    • Callable的call()可以抛出异常。而Runnable只有通过setUncaughtExceptionHandler()的方式才能在主线程中捕捉到子线程异常。

      class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println("实现Runnable接口");
        int i = 10/0;
    }
}
public class CreateThread {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println(t + "\t"+e.getMessage());
            }
        });
        thread.start();
    }
}

3 线程池

3.1 为什么要使用线程池

使用线程池主要有以下三个原因：

  1. 创建/销毁线程需要消耗系统资源，线程池可以复用已创建的线程。
  2. 控制并发的数量。并发数量过多，可能会导致资源消耗过多，从而造成服务器，从而造成服务器崩溃。
  3. 可以对线程做统一管理。

3.2 线程池原理

Java中线程池顶层接口是Executor接口，ThreadPoolExecutor 是这个接口的实现类。

先看看ThreadPoolExecutor类。

ThreadPoolExecutor提供的构造方法

// 五个参数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)
// 六个参数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)
// 六个参数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler)     
// 七个参数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

七大参数分析

  • int corePoolSize：该线程池中常驻核心线程数。

    核心线程：线程池中有两类线程，核心线程和非核心线程。核心线程默认情况下会一直存在于线程池中，即使这个核心线程什么都不干（铁饭碗），而非核心线程如果长时间的闲置，就会被销毁（临时工）。

  • int maximumPoolSize：该线程池中线程总数最大值。

    该值等于核心线程数量 + 非核心线程数量。

  • long keepAliveTime：非核心线程闲置超时时长

    非核心线程如果处于闲置状态超过该值，就会被销毁。

  • TimeUnit unit：keepAliveTime的单位。

  • BlockingQueue workQueue：阻塞队列，维护着等待执行的Runnable任务对象。

    常见的几个阻塞队列：

    1. LinkedBlockingQueue：链式阻塞队列，底层数据结构是链表，默认大小是Integer.MAX_VALUE ，也可以指定大小。
    2. ArrayBlockingQueue：数组阻塞队列，底层数据结构是数组，需要指定队列的大小。
    3. SynchronousQueue：同步队列，内部容量为0，每个put操作必须等待一个take操作，反之亦然。
    4. DelayedWorkQueue：延迟队列，该队列中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。

  • RejectedExecutionHandler handler ：拒绝策略，表示当阻塞队列满了，并且工作线程大于等于线程池的最大线程数（maximumPoolSize）时如何来拒绝请求执行的runnable的策略)。

  • ThreadFactory threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程，一般默认的即可。

线程池底层工作原理

  1. 在创建了线程池后，开始等待请求。
  2. 当调用execute()方法添加一个请求任务时，线程池会做出如下判断：
    1. 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；
    2. 如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入阻塞队列；
    3. 如果这个时候阻塞队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；
    4. 如果阻塞队列满了且正在运行的线程数量大于或等于maximumPoolSize,那么线程池会启动饱和和拒绝策略来执行。
  3. 当一个线程完成任务时，它会从阻塞队列中去下一个任务来执行。
  4. 当一个线程无事可做超过一定的时间（keepAliveTime)时，线程会判断： 如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉；所以线程池的所有任务完成后，它最终会收缩到corePoolSize的大小

四种拒绝策略

  1. ThreadPoolExecutor.AbortPolicy：默认拒绝处理策略，丢弃任务并抛出RejectedExecutionException异常。
  2. ThreadPoolExecutor.DiscardPolicy：丢弃新来的任务，但是不抛出异常。
  3. ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列中等待最久的任务，然后把当前任务加入队列中。
  4. ThreadPoolExecutor.CallerRunsPolicy：调用任务的run方法绕过线程池直接执行。

3.3 五种常见的线程池

Executors 类中提供的⼏个静态⽅法来创建线程池。

  1. newCachedThreadPool：maximumPoolSize最大可以至Integer.MAX_VALUE，存在OOM风险。线程可回收。

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

  2. newScheduledTheadPool：线程数最大至Integer.MAX_VALUE，存在OOM风险。线程不可回收。

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
 }
 public ScheduledThreadPoolExecutor(int corePoolSize) {
     super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
     new DelayedWorkQueue());
 }

  3. newSingleThreadPool：创建一个单线程的线程池，相当于单线程串行执行所有任务，保证按任务的提交顺序依次执行。

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

  4. newFixedThreadPool：固定线程数，不存在非核心线程（空闲线程）。

      public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

  5. newWorkStealingPool：JDK8引入，创建持有足够线程的线程池支持给定的并行度，并通过使用多个队列减少竞争，此构造方法中把CPU的数量设置为默认的并行度。适合使用在很耗时的任务中。

    public static ExecutorService newWorkStealingPool() {
    return new ForkJoinPool
    (Runtime.getRuntime().availableProcessors(),
    ForkJoinPool.defaultForkJoinWorkerThreadFactory,
    null, true);
}
Nan,气冲天.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java 网络编程 — Socket 编程【前置知识点】
小牛肉的博客
12-21 267
网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。学习 Socket 网络编程有助于我们了解 Netty
Netty 实战：实现聊天功能【前置知识点】
小牛肉的博客
12-21 242
通过本实例掌握 Netty 的基本使用
学习多线程之前需提前了解的小知识
老陈聊架构
06-06 599
什么是进程？ 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 什么是线程？ 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 什么是多线程？ 多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是...
学习多线程前的必备知识
爪哇岛民工的博客
02-18 444
线程与进程 对于操作系统来说，一个任务就是一个进程（Process），比如QQ。 进程是系统进行资源分配和调度的基本单位 在一个进程内部，运行的子任务就是线程（Thread），比如QQ的一个聊天窗口 线程是操作系统进行运算调度的最小单位 在同一进程中的各个线程，都可以共享该进程所拥有的资源 协程运行在线程之上，协程并没有增加线程数量，只是在线程的基础之上通过分时复用的方式运行多个协程 线程是动态概念，它的动态特性由线程控制块TCB（Thread Control Block）描述。TCB包括以下信息： （1
学习高并发的前置知识——Java中的线程基础
爱分享的板栗老哥
07-05 120
会有些朋友不是很能理解上期关于内存的知识，这里再给大家讲讲Java中的一些线程知识，希望可以给大家带来一些启发。 线程创建、运行 Java中的三种线程创建方式 一起吹水聊天 Thread public class ThreadTest { public static class MyThread extends Thread { @Override public void run() { // this获取当前线程，相当于Thread.cur
Java多线程——》如何在线程池执行任务前后做额外处理
小仙~
05-13 363
try { // 前置增强 beforeExecute(wt, task); try { // 执行任务 task.run(); } catch (Throwable x) { thrown = x; throw new Error(x); } finally { // 后置增强 afterExecute(task, thrown); } } // 继承线程池，重写这2个方法 protected void before.
Python自动化多线程测试-单线程/多线程
12-14
在Python编程领域，自动化测试是提高效率和质量的关键技术之一，尤其在软件测试过程中。本文将深入探讨如何利用Python进行自动化多线程测试，以及...理解并熟练运用这些知识点，对于提升Python软件测试的技能至关重要。
A.关于图计算&图学习的基础知识概览：前置知识点学习（Paddle Graph L）【一】
丨汀、的博客
11-08 901
因为篇幅关系就只放了部分程序在第三章，如有需求可自行fork项目原始链接。欢迎fork本项目原始链接：关于图计算&图学习的基础知识概览：前置知识点学习（Paddle Graph L）因为之前一直在研究知识提取相关算法，后续为了构建小型领域知识图谱，会用到知识融合、知识推理等技术，现在开始学习研究图计算相关。
序列化协议 Protostuff 基本使用【前置知识点】
小牛肉的博客
12-20 300
protostuff 是针对 Java 的序列化框架，基于 Google protobuf，但是提供了更多的功能和更简易的用法。虽然更加易用，但是不代表 ProtoStuff 性能更差。
并发[0] 基础篇
wjs_marvin的博客
07-08 151
并发[0] 基础篇 进程 & 线程 背景 最初的计算机只能接受一些特定的指令，用户每输入一个指令，计算机就做出一个操作。当用户在思考或者输入时，计算机就在等待。这样效率非常低下，在很多时候，计算机都处在等待状态。 批处理操作系统 把一系列的指令写下来，形成一个清单一次性交给计算机，一次性交给计算机。用户将多个需要执行的程序写在磁带上，然后交由计算机去读取并逐个执行这些程序，并将输出结果写在另一个磁带上。 批处理系统一定程度上提高计算机的效率，但是指令执行仍然是串行执行，一个指令须等待上一个指令执行
2.等待线程终止的Thread.join方法
jainszhang的博客
09-15 648
定义：主线程中执行子线程Thread.join()方法会让主线程等待子线程执行完毕。 1.主线程调用子线程的join方法后阻塞自己等待子线程返回 代码举例： main主线程首先会在调用threadOne.join（）方法后被阻塞，等待threadOne执行完毕后返回。然后主线程调用threadTwo.join（）方法后再次被阻塞，等待threadTwo执行完毕后返回。 CountDownLatch工具更好用。 //等待线程终止的join方法 Thread threadOne
Thread 中的 join() 方法的作用是调用线程等待该线程运行完后，再继续运行
tfish的专栏
03-02 752
Thread 中的 join() 方法的作用是调用线程等待该线程运行完后，再继续运行 例子： // public class JoinTest { // public static void main(String[] a){ System.out.println("main thread start"); Thread t1 = new Thread(new Worker("...
线程dump
ken-jl 的专栏
05-06 637
当应用程序运行变慢或者发生故障时，可能通过分析java的Thread Dumps得到分析他们得到阻塞和存在瓶颈的线程。线程堆栈是虚拟机中线程（包括锁）状态的一个瞬间状态的快照，即系统在某一个时刻所有线程的运行状态，包括每一个线程的调用堆栈，锁的持有情况。主要包含的信息包括  1、线程名字，id，线程的数量等。   2、线程的运行状态，锁的状态（锁被哪个线程持有，哪个线程在等待锁等）   3、调用堆...
java.lang.IllegalThreadStateException
xukuitao的博客
03-19 645
public class WhatTODO extends Thread { public WhatTODO(String name){ super(name); } @Override public void run(){ System.out.println(this.getName()+"========="); }...
线程基础
weixin_42158657的博客
10-06 139
需要了解程序会有线程安全问题， 必须要知道程序在jvm中是怎么运行的，运行的时候怎么就导致了线程安全问题了。 一、JVM运行的时的数据区域 jvm运行的数据区域分为：方法区、堆内存、虚拟机栈、本地方法栈、程序计数器。其中方法区和堆内存是线程共享的数据区域，虚拟机栈和本地方法栈、程序技术器是线程独占数据区域。如下图所示： 线程独占：每个线程都会有他的独立空间，随着线程的生命周期而创建和销毁 线程共...
spring事务详细讲解-深入浅出
小电玩
09-08 445
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
最新发布
m0_63550220的博客
09-08 1437
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值