多线程解析

最新推荐文章于 2024-04-17 09:15:08 发布
最新推荐文章于 2024-04-17 09:15:08 发布
阅读量881 收藏
点赞数
文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19462809/article/details/123772415
版权

1.概念

1.1. 回顾线程创建方式

  • 继承Thread
  • 实现Runnable

1.2. 线程的状态

在这里插入图片描述

  • New：刚刚创建，没做任何操作
Thread thread = new Thread(); 
System.out.println(thread.getState());
  • RUNNABLE：调用run，可以执行，但不代表一定在执行（RUNNING,READY）
thread.start();
System.out.println(thread.getState());
  • BLOCKED：抢不到锁
final byte[] lock = new byte[0]; 
new Thread(new Runnable() { 
	public void run() { 
		synchronized (lock){ 
			try {
				Thread.sleep(3000); 
			} catch (InterruptedException e) {
				e.printStackTrace(); 
			}
		} 
	}
}).start(); 
Thread thread2 = new Thread(new Runnable() { 
	public void run() { 
		synchronized (lock){ 
		}
	} 
});
thread2.start(); 
Thread.sleep(1000); 
System.out.println(thread2.getState());
  • WAITING
Thread thread2 = new Thread(new Runnable() {
	public void run() { 
		LockSupport.park();
	} 
}); 
thread2.start(); 
Thread.sleep(500); 
System.out.println(thread2.getState()); 
LockSupport.unpark(thread2); 
Thread.sleep(500); 
System.out.println(thread2.getState());
  • TIMED_WAITING
Thread thread3 = new Thread(new Runnable() {
    public void run() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
thread3.start();
Thread.sleep(500);
System.out.println(thread3.getState());
  • TERMINATED
//等待1s后再来看 
Thread.sleep(1000); 
System.out.println(thread.getState());

1.3.线程池基本概念

根据上面的状态，普通线程执行完，就会进入TERMINATED销毁掉，而线程池就是创建一个缓冲池存放线程，执 行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等候下次任务来临，这使得线程池比手动 创建线程有着更多的优势：

  • 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗
  • 提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行
  • 方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM
  • 节省cpu切换线程的时间成本（需要保持当前执行线程的现场，并恢复要执行线程的现场）
  • 提供更强大的功能，延时定时线程池。（Timer vs ScheduledThreadPoolExecutor）

1.4. 常用线程池类结构

可以通过idea查看到 （查看：ScheduledThreadPoolExecutor，ForkJoinPool类图）
在这里插入图片描述
说明：

  • 最常用的是ThreadPoolExecutor
  • 调度用ScheduledThreadPoolExecutor
  • 任务拆分合并用ForkJoinPool
  • Executors是工具类，协助你创建线程池的

2. 工作机制

在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部 协调空闲的线程，如果有，则将任务交给某个空闲的线程。一个线程同时只能执行一个任务，但可以同时向一个线 程池提交多个任务。

2.1. 线程池状态

在这里插入图片描述

  • RUNNING：初始化状态是RUNNING。线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务 数为0。RUNNING状态下，能够接收新任务，以及对已添加的任务进行处理。
  • SHUTDOWN：SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。调用线程池的shutdown()接口 时，线程池由RUNNING -> SHUTDOWN。
//shutdown后不接受新任务，但是task1，仍然可以执行完成 
ExecutorService poolExecutor = Executors.newFixedThreadPool(5);
poolExecutor.execute(new Runnable() {
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println("finish task 1");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
poolExecutor.shutdown();
poolExecutor.execute(new Runnable() {
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
System.out.println("ok");
  • STOP：不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。调用线程池的shutdownNow()接 口时，线程池由(RUNNING 或 SHUTDOWN ) -> STOP
    注意：运行中的任务还会打印，直到结束，因为调的
//改为shutdownNow后，任务立马终止，sleep被打断，新任务无法提交，task1停止 
poolExecutor.shutdownNow();
  • TIDYING：所有的任务已终止，队列中的”任务数量”为0，线程池会变为TIDYING。线程池变为TIDYING状态 时，会执行钩子函数terminated()，可以通过重载terminated()函数来实现自定义行为
//自定义类，重写terminated方法 
public class MyExecutorService extends ThreadPoolExecutor {
    public MyExecutorService(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    @Override
    protected void terminated() {
        super.terminated();
        System.out.println("treminated");
    }

    //调用 shutdownNow， ternimated方法被调用打印 
    public static void main(String[] args) throws InterruptedException {
        MyExecutorService service = new MyExecutorService(1, 2, 10000, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(5));
        service.shutdownNow();
    }
}
  • TERMINATED：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED

2.2. 结构说明

（源码查看：两个集合，一个queue，一个hashset）
在这里插入图片描述

2.3.任务的提交

  • 添加任务，如果线程池中线程数没达到coreSize，直接创建新线程执行
  • 达到core，放入queue
  • queue已满，未达到maxSize继续创建线程
  • 达到maxSize，根据reject策略处理
  • 超时后，线程被释放，下降到coreSize

3. 源码解析

//任务提交阶段：（4个if条件路线） 
    public void execute(Runnable command) {
        if (command == null) throw new NullPointerException();
        int c = ctl.get();
        //判断工作数，如果小于coreSize，addWork，注意第二个参数core=true 
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true)) return;
            c = ctl.get();
        }
        //否则，如果线程池还在运行，offer到队列 
        if (isRunning(c) && workQueue.offer(command)) {
            //再检查一下状态
            int recheck = ctl.get();
            //如果线程池已经终止，直接移除任务，不再响应 
            if (!isRunning(recheck) && remove(command)) reject(command);
                //否则，如果没有线程干活的话，创建一个空work，该work会从队列获取任务去执行 
            else if (workerCountOf(recheck) == 0) addWorker(null, false);
        }
        //队列也满，继续调addWork，但是注意，core=false，开启到maxSize的大门 
        // 超出max的话，addWork会返回false，进入reject 
        else if (!addWorker(command, false)) reject(command);
    }

    //线程创建
    private boolean addWorker(Runnable firstTask, boolean core) {
        //第一步，计数判断，不符合条件打回false
        retry:
        for (; ; ) {
            int c = ctl.get();
            int rs = runStateOf(c);
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty())) return false;
            for (; ; ) {
                int wc = workerCountOf(c);
                //判断线程数，注意这里！ 
                // 也就说明线程池的线程数是不可能设置任意大的。 
                // 最大29位（CAPACITY=29位二进制） 
                if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false;
                if (compareAndIncrementWorkerCount(c)) break retry;
                c = ctl.get();// Re‐read ctl
                if (runStateOf(c) != rs) continue retry;
                // else CAS failed due to workerCount change; retry inner loop 
            }
        }
        //第二步，创建新work放入线程集合works（一个HashSet） 
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            //符合条件，创建新的work并包装task 
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock. 
                    // Back out on ThreadFactory failure or if 
                    // shut down before lock acquired. 
                    int rs = runStateOf(ctl.get());
                    if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive())// precheck that t is startable 
                            throw new IllegalThreadStateException();
                        //在这里！！！
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize) largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    //注意，只要是成功add了新的work，那么将该新work立即启动，任务得到执行 
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (!workerStarted) addWorkerFailed(w);
        }
        return workerStarted;
    }
    //任务获取与执行 
    // 在worker执行runWorker()的时候，不停循环，先查看自己有没有携带Task，如果有，执行 
    while(task!=null||(task=getTask())!=null)

    //如果没用，会调用getTask，从队列获取任务 
    private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?
        for (; ; ) {
            int c = ctl.get();
            int rs = runStateOf(c);
            // Check if queue empty only if necessary. 
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            int wc = workerCountOf(c);
            // Are workers subject to culling? 
            // 判断是不是要超时处理，重点！！！决定了当前线程要不要被释放 
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            //线程数超出max，并且上次循环中poll等待超时了，那么说明该线程已终止
            // 将线程队列数量原子性减
            if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c)) return null;
                continue;
            }
            try {
                //重点！！！ 
                // 如果线程可被释放，那就poll，释放的时间为：keepAliveTime 
                // 否则，线程是不会被释放的，take一直被阻塞在这里，知道来了新任务继续工作 
                Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();
                if (r != null) return r;
                //到这里说明可被释放的线程等待超时，已经销毁，设置该标记，下次循环将线程数减少 
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

完整流程回顾：
在这里插入图片描述

4. 注意点

4.1. 线程池是如何保证线程不被销毁的呢？

答案：如果队列中没有任务时，核心线程会一直阻塞在获取任务的方法，直到返回任务。而任务执行完后，又会进 入下一轮 work.runWork()中循环
验证：秘密就藏在核心源码里 ThreadPoolExecutor.getTask()

//work.runWork(): 
while (task != null || (task = getTask()) != null) //work.getTask(): 
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
Runnable r = timed ? 
	workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS):workQueue.take();

4.2. 那么线程池中的线程会处于什么状态？

答案：TIMED_WAITING,RUNNABLE,WAITING
验证：起一个线程池，放置一个任务sleep，debug查看结束前后的状态

//debug add watcher: 
((ThreadPoolExecutor)poolExecutor).workers.iterator().next().thread.getState()

ThreadPoolExecutor poolExecutor = Executors.newFixedThreadPool(5);
poolExecutor.execute(new Runnable() {
     public void run() {
         try {
             Thread.sleep(5000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 });
 System.out.println("ok");

4.3. 核心线程与非核心线程有区别吗？

答案：没有。被销毁的线程和创建的先后无关。即便是第一个被创建的核心线程，仍然有可能被销毁
验证：看源码，每个works在runWork的时候去getTask，在getTask内部，并没有针对性的区分当前work是否是核 心线程或者类似的标记。只要判断works数量超出core，就会调用poll()，否则take()

5. Executors工具

以上构造函数比较多，为了方便使用，提供了一个Executors工具类

  • newCachedThreadPool() ： 弹性线程数
  • newFixedThreadPool(int nThreads) ： 固定线程数
  • newSingleThreadExecutor() : 单一线程数
  • newScheduledThreadPool(int corePoolSize) ： 可调度，常用于定时
鱼遇熊掌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 调用其他线程_java 后台接口另起一个线程执行其他业务
weixin_39986060的博客
02-13 1027
直接post代码，然后在详细介绍为什么：packagecom.xxx.testset.service.impl;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/**** @function xxx接口实现类*@authorLiangjw* @date 2019-9-18 下午02:...
线程池Executor框架解读
桐花思雨
05-30 508
目录`Executor` 整体架构 Executor 整体架构 接口/类说明Executor该接口只有一个execute方法，目的是将任务提交和执行解耦ExecutorService该接口对Executor接口进行了拓展，定义了对线程池中线程的管理方法AbstractExecutorService对ExecutorService接口中部分方法的实现ThreadPoolExecutor线程池的最终实现，实现了线程池工作的完整机制，是整个框架的重点ForkJoinPool实现了Fork/Join模式的线程池S
Executor的用法(线程、异步)
atrueman123的专栏
08-26 2053
ExecutorService是Executor的子类public interface ExecutorServiceextends ExecutorExecutor 提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。 可以关闭 ExecutorService，这将导致其停止接受新任务。关闭后，执行程序将最后终止，这时没有任务在执行，也没有任务在等待执行，并且无法提交新任务。 通过创建并返回一个可用于取消执行和/或等待完成的 Future，方法 submit 扩展了基
线程池ExecutorService中submit 和 execute的区别
weixin_43866043的博客
04-26 2740
ExecutorService线程池执行线程时有submit 和execute 两种方法 executorService.execute 无返回值，直接执行，因此不能阻塞线程，并且在执行异常时会抛出异常 executorService.submit 有三种类型，接返回future，可以阻塞获取线程执行结果，在执行异常时会被异常处理吃掉，不会抛出异常 区别如下 package juc; import java.sql.Time; import java.util.concurrent.*; public
executor.execute()与 executor.submit()区别
最新发布
qq_31532979的博客
04-17 1435
方法则适用于需要获取任务结果、进行精细的异常处理、监控任务状态或可能需要取消任务的情况。提供了诸如检查任务是否已完成、阻塞等待任务完成、获取任务结果或取消任务等操作。方法更适合用于提交不需要返回结果、异常处理相对简单且不需要取消功能的任务。接口的任务，这类任务没有返回值，通常用于执行纯粹的操作或计算。方法，允许尝试取消尚未开始或正在进行的任务。：当提交的任务在执行过程中抛出异常时，该异常将被传递给线程的。提交一个任务时，无法直接获取任务执行的结果或状态。，所以无法直接取消已提交的任务或查询其执行状态。
Java 并发之线程篇
新青年1号
09-16 309
Java 并发编程 Java 创建多线程的方式 继承 Thread 类 // 自定义线程类，继承 Thread 类 public class MyThread extends Thread{ // 线程的运行逻辑 public void run(){ System.out.println("My Thread run ... "); } } // 定义测试类 public class MyThreadTest{ public static void ma
ExecutorService线程池+七大参数源码分析+自定义线程池
WonderKing'blog
04-21 1536
例子： 10年前单核CPU电脑，假的多线程，像马戏团小丑玩多个球，CPU需要来回切换。 现在是多核电脑，多个线程各自跑在独立的CPU上，不用切换效率高。 线程池的优势： 线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。 它的主要特点为：线程复用;...
java多线程解析
08-29
【Java多线程解析】 Java中的多线程技术是编程中的一个重要领域，它允许程序同时执行多个任务，从而更高效地利用CPU资源。在Java中，多线程主要用于模拟现实世界中的并发行为，例如"生产者-消费者"模型。本文将深入...
Java多线程 实例解析
08-30
"Java多线程实例解析" Java多线程是指在同一个程序中可以同时运行多个线程，以提高程序的执行效率和响应速度。Java中有三种实现多线程的方式：继承Thread类、实现Runnable接口和实现Callable接口。 继承Thread类 ...
RSS下载多线程解析老代码
11-21
本话题聚焦于一个“RSS下载多线程解析老代码”的实例，虽然这个代码可能已无法直接编译，但它仍然可以作为一个学习多线程处理和RSS解析的基础。 首先，我们需要理解RSS下载的基本流程。当用户订阅了一个RSS源，...
Linux下的多线程编程实例解析
09-14
【Linux下的多线程编程实例解析】 在计算机操作系统中，多线程编程是实现并行处理和提高系统效率的一种重要技术。Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多...
易语言-json解析的单线程与多线程操作实例
06-29
本实例主要探讨的是如何在易语言环境中进行JSON数据的解析，以及如何利用多线程技术提高程序执行效率。 JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，同时也易于机器解析和...
Java线程池 ExecutorService
ywb201314的专栏
09-27 392
本篇主要涉及到的是java.util.concurrent包中的ExecutorService。ExecutorService就是Java中对线程池的实现。 一、ExecutorService介绍 ExecutorService是Java中对线程池定义的一个接口，它java.util.concurrent包中，在这个接口中定义了和后台任务执行相关的方法： Java API对ExecutorService接口的实现有两个，所以这两个即是Java线程池具体实现类（详细了解这两个实现类，点击这里）： .
Java线程池使用详解及原理
白鸽
10-13 1125
线程池其实是一种池化的技术的实现，池化技术的核心思想其实就是实现资源的一个复用，避免资源的重复创建和销毁带来的性能开销。在线程池中，线程池可以管理一堆线程，让线程执行完任务之后不会进行销毁，而是继续去处理其它线程已经提交的任务。通过上面分析提到，通过Executors这个工具类来创建的线程池其实都无法满足实际的使用场景，那么在实际的项目中，到底该如何构造线程池呢，该如何合理的设置参数？1）线程数线程数的设置主要取决于业务是IO密集型还是CPU密集型。
Java并发包：ExecutorService和ThreadPoolExecutor
charming的专栏
07-12 1万+
文章译自：http://tutorials.jenkov.com/java-util-concurrent/index.html 抽空翻译了一下这个教程的文章，后面会陆续放出，如有不妥，请批评指正。 转自请注明出处。 ExecutorServiceJava.util.concurrent.ExecutorService接口代表一种异步执行机制，它能够在后台执行任务。因此ExecutorSer
线程Thread和Runnable接口的区别
SiShen654的博客
06-25 422
1-Thread类 当一个类继承Thread时，对run方法进行重写。每一个对象的run方法所调用的资源除了静态资源类外，是不互通的 每当调用该类创建一个对象时，run里面所创建的资源也将被创建一次 run(){ for(i=0;i<10;i++){ System.out.println( i ) } } 每一个线程对象都会调用十次输出i！！！ 2-Runnable接口 当newRunnable类继承该接口后，对run方法进行同上的重写，所有的线程类对象参数为同一个newRunna
ExecutorService的execute和submit方法
sprita1的专栏
04-03 6504
因为之前一直是用的execute方法，最近有个情况需要用到submit方法，所以研究了下。 三个区别： 1、接收的参数不一样 2、submit有返回值，而execute没有 Method submit extends base method Executor.execute by creating and returning a Future that can
Executor
Robin Hu的专栏
11-24 1291
Executor java.util.concurrent 接口 Executor 所有已知子接口：     ExecutorService, ScheduledExecutorService 所有已知实现类：     AbstractExecutorService, ScheduledThreadPoolExecutor, ThreadPoolExecutor 它用于执行Runna
Java线程池ThreadPoolExecutor中execute()方法原理
热门推荐
山鬼谣的专栏
02-24 2万+
环境 Java：1.8 前言 线程池之前知是知道，但是印象不是很深刻，今天看了下源码，发现源码很好理解，所以记录下； 线程池 要了解线程池，首先要了解线程池里面的状态控制变量ctl。 线程池的ctl是一个原子的AtomicInteger 这个ctl包含两个参数： runState 线程的状态 workerCount 激活的线程数 它的低29位用于存放当前的线程数，因此一个线程池在理论上最...
Java多线程解析：线程通信与优势
本资源主要探讨了Java中的线程间通信和多线程的基本概念，适合于学习Java多线程的读者。通过PipedOutputStream和PipedInputStream的示例展示了如何通过中间类实现线程间的通信。此外，还介绍了线程的挂起与唤醒、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值