精华内容
下载资源
问答
  • 理论: 1 Executors 预置 4种线程池: Fixed SingleThread cached ...将Callable对象submit 线程池中,会返回Future对象,然后 可以通过get 获取对应数据,但是会等待 3 ExecutorCompletionService 接收线程队...

    理论:

    1 Executors 预置 4种线程池: Fixed  SingleThread  cached  Scheduled 
    2 FutureTask 使用方法: 新建callable<T>对象;将Callable对象submit 线程池中,会返回Future对象,然后 可以通过get 获取对应数据,但是会等待
    3 ExecutorCompletionService 接收线程队列,内置一个BlockingQueue,有数据才返回

     

     


    线程池: 
      ThreadPoolExecutor : 
       CorepoolSize  核心池大小
       MaxPoolSize 最大池大小 ,只有工作对列满了,才会扩大最大池
       KeepAliveTime 空闲线程保留时间
       TimeUnit  保留单位
       WorkQueue  工作对列,
       ThreadFactory 线程工厂,主要定制线程名称
       RejectedExecutionHandler :饱和策略,默认为AbortPolicy, 饱和就废弃,但是会抛出 RejectedExecutionException(非检查异常)

     

    线程池使用说明corepoolsize maxpoolsize后台使用队列
    newCachedThreadPool无限容量线程池运行队列;0Integer.MAX_VALUESynchronousQueue:无容量、无缓冲队列
    newFixedThreadPool固定线程池队列
     Executors.newFixedThreadPool(1);
    定义时指定与corepoolsize 相同LinkedBlockingQueue 无限队列
    newSingleThreadExecutor顺序运行队列,FIFO,一次只执行一个线程11LinkedBlockingQueue 无限队列
    newScheduledThreadPool线程定时任务执行器;可以放置无限多线程执行,并且可以使用固定周期 与固定时延方式运行线程,一般用于执行定时任务,不会放置无限多线程。定义时指定Integer.MAX_VALUEDelayedWorkQueue 无限容量堆数组

     

    TestCachedThreadExecutors

    /**
     * newCachedThreadPool  corepool size 0, maxpool  无限大,
     * 后台使用了 SynchronousQueue 无容量无缓冲等待队列,线程直接交给maxpool去执行
     * 可以并行运行无限大线程池,并且线程池可以复用(前一个线程用完即可)
     */
    public class TestCachedThreadExecutors {
    
        private CountDownLatch cdLatch = new CountDownLatch(3);
    
        public static void main(String[] args) {
    
            Executor cachedExecutors =  Executors.newCachedThreadPool();
            ThreadTask t1 = new ThreadTask();
            ThreadTask t2 = new ThreadTask();
            ThreadTask t3 = new ThreadTask();
    
            cachedExecutors.execute(t1);
            cachedExecutors.execute(t2);
            cachedExecutors.execute(t3);
            showVM();
    
            for(int i=0;i<1000;i++){
                ThreadTask t  = new ThreadTask();
                cachedExecutors.execute(t);
                if(i%100==0){showVM();
                System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
            }
    
    
        }
    
    
        public static class ThreadTask  implements  Runnable{
    
            private Byte[] datas = new Byte[10240];
    
            @Override
            public void run() {
                try {
    
                    Thread.sleep(5000l);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        private static void showVM(){
            List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
            for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
                System.out.println("Name:" + memoryPoolMXBean.getName());
                System.out.println("Usage:" + memoryPoolMXBean.getUsage());
                System.out.println("Manager:" +","+  memoryPoolMXBean.getMemoryManagerNames());
                System.out.println("Type:" + memoryPoolMXBean.getType());
                System.out.println("--------------------------");
            }
        }
    }
    
    TestFixedThreadExecutors
    /**
     * newFixedThreadPool corePoolSize = maxPoolSize,
     * 后台使用了 LinkedBlockingQueue 无限队列,可以放置无限多线程
     */
    public class TestFixedThreadExecutors {
    
        private CountDownLatch cdLatch = new CountDownLatch(3);
    
        public static void main(String[] args) {
    
            Executor fixedExecutors =  Executors.newFixedThreadPool(1);
            ThreadTask t1 = new ThreadTask();
            ThreadTask t2 = new ThreadTask();
            ThreadTask t3 = new ThreadTask();
    
            fixedExecutors.execute(t1);
            fixedExecutors.execute(t2);
            fixedExecutors.execute(t3);
    
            showVM();
    
            for(int i=0;i<1000;i++){
                ThreadTask t  = new ThreadTask();
                fixedExecutors.execute(t);
                if(i%100==0){showVM();
                System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
            }
    
    
        }
    
    
        public static class ThreadTask  implements  Runnable{
    
            private Byte[] datas = new Byte[1024000];
    
            @Override
            public void run() {
                try {
    
                    Thread.sleep(5000l);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        private static void showVM(){
            List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
            for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
                System.out.println("Name:" + memoryPoolMXBean.getName());
                System.out.println("Usage:" + memoryPoolMXBean.getUsage());
                System.out.println("Manager:" +","+  memoryPoolMXBean.getMemoryManagerNames());
                System.out.println("Type:" + memoryPoolMXBean.getType());
                System.out.println("--------------------------");
            }
        }
    }
    TestSingleThreadExecutors
    /**
     * newSingleThreadExecutor  一次执行一个线程,并且保证线程顺序执行,
     * 后台使用了 LinkedBlockingQueue 无限队列,可以放置无限多线程
     */
    public class TestSingleThreadExecutors {
    
        private CountDownLatch cdLatch = new CountDownLatch(3);
    
        public static void main(String[] args) {
    
            Executor singleExecutors =  Executors.newSingleThreadExecutor();
            ThreadTask t1 = new ThreadTask();
            ThreadTask t2 = new ThreadTask();
            ThreadTask t3 = new ThreadTask();
    
            singleExecutors.execute(t1);
            singleExecutors.execute(t2);
            singleExecutors.execute(t3);
            showVM();
    
            for(int i=0;i<1000;i++){
                ThreadTask t  = new ThreadTask();
                singleExecutors.execute(t);
                if(i%100==0){showVM();
                System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
            }
    
    
        }
    
    
        public static class ThreadTask  implements  Runnable{
    
            private Byte[] datas = new Byte[1024];
    
            @Override
            public void run() {
                try {
    
                    Thread.sleep(5000l);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        private static void showVM(){
            List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
            for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
                System.out.println("Name:" + memoryPoolMXBean.getName());
                System.out.println("Usage:" + memoryPoolMXBean.getUsage());
                System.out.println("Manager:" +","+  memoryPoolMXBean.getMemoryManagerNames());
                System.out.println("Type:" + memoryPoolMXBean.getType());
                System.out.println("--------------------------");
            }
        }
    }
    TestScheduledThreadExecutors
    /**
     * newScheduledThreadPool  corepool 用户设置, maxpool  无限大,
     * 后台使用了 DelayedWorkQueue 无限制容量堆数组,线程直接交给maxpool去执行
     * 可以放置无限多线程执行,并且可以使用固定周期 与固定 时延方式运行线程
     * 一般不会放置无限多线程。
     */
    public class TestScheduledThreadExecutors {
    
        private CountDownLatch cdLatch = new CountDownLatch(3);
    
        public static void main(String[] args) {
    
            ScheduledExecutorService scheduledExecutorService =  Executors.newScheduledThreadPool(3);
            ThreadTask t1 = new ThreadTask();
            ThreadTask t2 = new ThreadTask();
            ThreadTask t3 = new ThreadTask();
    
            scheduledExecutorService.schedule(t1,3, TimeUnit.SECONDS);
            scheduledExecutorService.scheduleAtFixedRate(t2,2000,2000,TimeUnit.SECONDS);
            scheduledExecutorService.scheduleWithFixedDelay(t3,2000,2000,TimeUnit.SECONDS);
    
            showVM();
    
            for(int i=0;i<1000;i++){
                ThreadTask t  = new ThreadTask();
                scheduledExecutorService.execute(t);
                if(i%100==0){showVM();
                System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
            }
    
    
        }
    
    
        public static class ThreadTask  implements  Runnable{
    
            private Byte[] datas = new Byte[10240];
    
            @Override
            public void run() {
                try {
    
                    Thread.sleep(5000l);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        private static void showVM(){
            List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
            for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
                System.out.println("Name:" + memoryPoolMXBean.getName());
                System.out.println("Usage:" + memoryPoolMXBean.getUsage());
                System.out.println("Manager:" +","+  memoryPoolMXBean.getMemoryManagerNames());
                System.out.println("Type:" + memoryPoolMXBean.getType());
                System.out.println("--------------------------");
            }
        }
    }
    TestCompletionService
    /**
     * 实现原理:ExecutorCompletionService 类,内部定义了一个 BlockingQueue<Future<T>>;
     * 当线程执行完成,有返回时,往 BlockingQueue 中add Futurn<T>;
     * 具体怎么判断线程执行完成呢:重载类FutureTask.done()方法,完成相关功能
     *
     * 使用场景:当使用线程池运行需要有返回值的线程时,为了获取结果不被阻塞,需要使用此方法
     */
    public class TestCompletionService {
    
    
    
        public static void main(String[] args) throws InterruptedException, ExecutionException {
             Executor executorService = Executors.newFixedThreadPool(3);
            List<Callable<String>> callableList = new ArrayList<>();
    
            for (int i = 0; i < 5; i++) {
    
                final String name = "name" + i;
                final int sleepTime = new Random().nextInt(10);
    
                Callable<String> callable = new Callable<String>() {
                    @Override
                    public String call() throws Exception {
    
                        System.out.println("Thread name :" + name + ",sleeptime :" + sleepTime);
                        TimeUnit.SECONDS.sleep(sleepTime);
                        return "found " + name;
                    }
                };
                callableList.add(callable);
            }
    
            CompletionService<String> completionService = new ExecutorCompletionService<String>(executorService);
    
            for (int i = 0; i < callableList.size(); i++)
                completionService.submit(callableList.get(i));
    
            for (int i = 0; i < callableList.size(); i++) {
                System.out.println("等待打印" + (i + 1) + "个返回值");
                System.out.println(completionService.take().get());
            }
    
        }
    
    }
    TestExecutorInvokeAll
    public class TestExecutorInvokeAll {
    
        public static void main(String[] args) throws InterruptedException, ExecutionException {
            ExecutorService executorService = Executors.newFixedThreadPool(5);
    
            List<Callable<String>> callableList = new ArrayList<>();
    
            for (int i = 0; i < 10; i++) {
                final String name = "Thread " + i;
                final int sleepTime = new Random().nextInt(10);
                Callable<String> callable = new Callable<String>() {
                    @Override
                    public String call() throws Exception {
                        System.out.println("begin " + name);
                        TimeUnit.SECONDS.sleep(sleepTime);
                        return name;
                    }
                };
    
                callableList.add(callable);
            }
    
            List<Future<String>> futureList = executorService.invokeAll(callableList, 5, TimeUnit.SECONDS);
    
            for (int i = 0; i < futureList.size(); i++) {
                if (!futureList.get(i).isCancelled()) {
                    System.out.println(futureList.get(i).get());
                } else {
                    System.out.println(callableList);
                }
            }
    
        }
    }
    TestThreadInterrupt
    /**
     * interrupt结论:
     * 1 interrupt() 可以中断线程;
     * 2 Thread.sleep() wait() /join()方法 检测到线程中断后,会抛出 InterruptedException 异常,然后清除中断状态(),线程回到正常状态
     * 3 Thread.interrupted() 判断当前线程状态,若未中断状态则返回true,并清除中断状态,线程回到正常状态; 若未中断,返回false,不去中断线程;
     * 4 Thread.currentThread().isInterrupted() 仅判断当前线程状态,若中断返回true,否则返回false;
    *interrupt 使用步骤:
    *1 制定中断策略
    *2 在合适地方中断线程,interrupt()
    *3 在业务流程决策点判断 线程中断状态
    *4 捕获线程中断异常,处理中断逻辑
     */
    
    public class TestThreadInterrupt {
        public static void main(String[] args) throws InterruptedException {
    
            MyRunnable myRunnable = new MyRunnable("Thread test");
            Thread t1 = new Thread(myRunnable);
            t1.start();
            Thread.sleep(10000l);
            t1.interrupt();
    
    
        }
    
    
        static class MyRunnable implements Runnable {
    
            private String name;
    
            public MyRunnable(String name) {
                this.name = name;
            }
    
            @Override
            public void run() {
                int i = 0;
                System.out.println("begin thread  " + name);
    
                while (i < 10 && !Thread.currentThread().isInterrupted()) {
                    try {
                        TimeUnit.SECONDS.sleep(2);
                        i++;
                        System.out.println("finish  loop  " + i);
    
                    } catch (InterruptedException e) {
                        System.out.println("Thread  " + name + " loop " + i + " encounter InterruptedException , and interrupt status: " + Thread.currentThread().isInterrupted());
    
                        System.out.println("after interruptedException check, thread isInterrupted() = " + Thread.currentThread().isInterrupted());
    
                        boolean interruptedFlag =  Thread.interrupted();
    
                        System.out.println("after interrupted() once , thread isInterrupted() = " + Thread.currentThread().isInterrupted() + ", interruptedFlag = " + interruptedFlag);
    
                        interruptedFlag =  Thread.interrupted();
    
                        System.out.println("after interrupted() twice , thread isInterrupted() = " + Thread.currentThread().isInterrupted() + ", interruptedFlag = " + interruptedFlag);
    
                          Thread.currentThread().interrupt();
    
                        System.out.println("after interrupt() , thread isInterrupted() = " + Thread.currentThread().isInterrupted() );
    
                        interruptedFlag =  Thread.interrupted();
    
                        System.out.println(" interrupted() after  interrupted(), interruptedFlag = " + interruptedFlag + ",thread isInterrupted() = " + Thread.currentThread().isInterrupted() );
    
    
                    }
    
                }
    
                System.out.println("end  thread  " + name);
    
            }
        }
    }
    

     

    展开全文
  • **java 线程池中如何自定义每个线程名称 java 线程池中如何自定义每个线程名称 **
  • 线程池execute线程后,用Thread.currentThread().getName() 获取不到本来的名字。 解决办法: 在线程的方法里面,用this.getName() 即可。

    线程池execute线程后,用Thread.currentThread().getName() 获取不到本来的名字。
    解决办法:
    在线程的方法里面,用this.getName() 即可。

    展开全文
  • * 如何获取线程的对象名称呢? * public final String getName():获取线程名称 * 如何设置线程对象名称 * public final void setName(String name):设置线程的名称 * * 针对不是Thread类中的子类如何获取...
    package cn.itcast_02;
    /*
     * 如何获取线程的对象名称呢?
     *    public final String getName():获取线程的名称
     * 如何设置线程对象名称
     * public final void setName(String name):设置线程的名称
     * 
     * 针对不是Thread类中的子类如何获取线程对象呢?
     * public static Thread currentThread();返回当前执行的线程对象
     * Thread.currentThread().getName
     * 
     * 
     */
    public class 获取和设置线程对象名称 {
          public static void main(String[] args) {
    		//创建线程对象
        	  //无参构造+seXxx();
    //    	  MyThread my1 = new MyThread();
    //    	  MyThread my2 = new  MyThread();
    //    	  
    //    	  //设置名称
    	   	  my1.setName("大台南");
     	  	  my2.setName("见过的");
    //    	  
    //    	  //启动线程
       	  my1.start();
        	  my2.start();
        	  
        	  //带参构造给线程起名字
        	  MyThread my1 = new MyThread("阿法狗");
        	  MyThread my2 = new  MyThread("绘画板");
        	  
        	   //启动线程
        	  my1.start();
        	  my2.start();
        	  
        	  //我要获取main方法的线程对象的名称,该怎么办呢?
        	  //遇到这种情况,Thread提供了一个方法
        	  //public static Thread currentThread();返回当前执行的线程对象
        	  System.out.println(Thread.currentThread().getName());
    	}
    }
    
    展开全文
  • 在线上发生的一次问题, 在场景中有这样一个业务, 需要异步执行一个主任务, 主任务中又包含着N个子任务,为了整个主任务能够快速处理, 又将子任务按照数量获取线程资源异步处理, 即异步线程A中再异步调用A1,A2,A3....

    问题描述

    在线上发生的一次问题, 在场景中有这样一个业务, 需要异步执行一个主任务, 主任务中又包含着N个子任务, 为了整个主任务能够快速处理, 又将子任务按照数量获取线程资源异步处理, 即异步线程A中再异步调用A1,A2,A3. A可能同时存在多个.实际场景中, 由于系统线程池分配数量较小, 且一段时间内先后启动了多个主任务, 耗时的主任务中又用子任务取申请线程 导致线程池资源耗尽

    问题原因

    1. 主任务是从线程池中获取的线程资源, 同时主任务比较耗时​
    2. 每个主任务中包含的N的子任务, 会再申请线程, 处理完毕释放回线程池
    3. 启动了多个主任务时, 每个主任务在未结束之前, 都会占用自身一个线程不会释放, 消耗一个线程池资源
    4. 后期频繁启动主任务, 可能使数量=线程池线程数, 此时子任务无法再从线程池获得资源, 就进入队列等待
    5. 最终结果就造成了每个主任务都占用线程, 但主任务内的子任务无法获取线程, 线程池瘫痪不可用

    问题复现

    package test;
    
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.RandomUtils;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @title 线程池异步线程中再次获取线程池资源的问题
     * @author Xingbz
     * @description
     *  记;
     *
     *  究其原因在于:
     *      
     * @createDate 2020-7-17
     */
    @Slf4j
    public class TestWork {
    
        private static final ThreadPoolTaskExecutor EXECUTOR;
    
        static {
            EXECUTOR = myExecutor();
        }
    
        /** 初始化线程池 */
        public static ThreadPoolTaskExecutor myExecutor() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            // 核心线程数
            executor.setCorePoolSize(5);
            // 最大线程数
            executor.setMaxPoolSize(20);
            // 排队任务队列
            executor.setQueueCapacity(100);
            // 线程名称前缀
            executor.setThreadNamePrefix("异步线程-");
            // 队列满后拒绝策略
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            // 线程最大回收时间
            executor.setKeepAliveSeconds(100);
            // 初始化线程
            executor.initialize();
            return executor;
        }
    
        /** 模拟测试 */
        public static void main(String[] args) throws Exception {
            // 主任务数量
            int mainJobNum = 20;
    
            CountDownLatch mainDownLatch = new CountDownLatch(mainJobNum);
    
            for (int i = 0; i < mainJobNum; i++) {
                // 主任务编号, 方便区分
                int index = i + 1;
    
                // 模拟每1秒开始一个主任务
                TimeUnit.SECONDS.sleep(1);
    
                EXECUTOR.submit(() -> {
                    try {
                        log.debug("\t执行主任务" + index);
    
                        // 每个主任务随机包含N个子任务, 再异步调用线程池资源处理
                        int subJobNum = RandomUtils.nextInt(2, 3);
                        subJobWorkAsync(subJobNum, index);
                    } finally {
                        mainDownLatch.countDown();
                    }
                });
            }
    
            mainDownLatch.await();
            EXECUTOR.shutdown();
            log.info("完成所有任务 > > >");
        }
    
        /** 异步执行子任务 */
        private static void subJobWorkAsync(int subJobNum, int index) {
            CountDownLatch subDownLatch = new CountDownLatch(subJobNum);
            for (int j = 0; j < subJobNum; j++) {
                EXECUTOR.submit(() -> {
                    try {
                        log.warn("\t\t\t执行一个" + index + "的子任务");
                        // 每个子任务模拟耗时
                        TimeUnit.SECONDS.sleep(3);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        subDownLatch.countDown();
                    }
                });
            }
    
            try {
                subDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    执行代码, 结果如下:

    控制台输出

    可以看到, 线程池很快就被主任务耗尽, 导致子任务无法执行.

    解决方案 

    1. 异步线程中不能再获取异步线程

    既然主方法是异步执行了, 那么其中的子任务也相对不那么要求时间.此处是我为了业务给另外一个业务复用导致了线程再调线程

    2. 如果异步中确实需要再获取异步线程, 需要使用新的线程池. 不能再使用自身的线程池

    这是当前我们的解决方案, 在系统中又单独构建了一个线程池负责子任务的业务

    展开全文
  • java线程 根据线程名称获取线程

    千次阅读 2020-08-21 10:48:17
    * 根据线程名称获取线程 * @param threadName * @return */ public Thread getThreadByName(String threadName) { for (Thread t : Thread.getAllStackTraces().keySet()) { if (t.getName().equals...
  • 线程池获取一个线程对象,并且执行给定的Runnable接口实现类对象作为执行目标 演示代码 package com.qfedu.b_executors; import java.util.concurrent.ExecutorService; import java.util.concurrent.Execut
  • java线程使用线程池 什么是线程? (What is a Thread?) A thread is a lightweight process. Any process can have multiple threads running in it. 线程是轻量级进程。 任何进程都可以在其中运行多个线程。 ...
  • 1.获取线程名称 参考:https://blog.csdn.net/luyaran/article/details/80595772  public class Main extends Thread {  public static void main(String[] args) {  Main t1 = new Main();  t1.setName(&...
  • 2.Java线程池 ThreadPoolExecutor(一)线程池的核心方法以及原理 https://blog.csdn.net/m0_37506254/article/details/90574038 3.Java 中的几种线程池,你之前用对了吗 https://www.cnblogs.com/fengzhe...
  • 点击上方☝,轻松关注!及时获取有趣有料的技术文章本文讲一下Java线程池中创建 ThreadFactory 设置线程名称的三种方式。设置线程名称是很重要的,如果你没有设置过,说明你还“涩...
  • Java线程启动

    2020-03-24 23:48:20
    一.java创建和启动线程较为常用的方式有继承Thread类、实现Runnable接口和匿名内部类的方式。 1.继承Thread类 1、定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务。...
  • java线程池概念.txt

    2019-08-16 10:14:03
    //获取当前线程池的锁 mainLock.lock();//加锁 try { /* 这里线程池线程大小还需要判断一次;前面的判断过程中并没有加锁,因此可能在execute方法判断的时候poolSize小于corePoolSize,而判断完之后,在其他线程...
  • 前言 多线程的异步执行方式,虽然能够最大限度发挥多核计算机的计算能力,但是如果不加控制,反而会对系统造成负担。线程本身也要占用内存空间,大量的线程会占用内存资源并且...为了避免重复的创建线程线程池的...
  • 反而会对系统造成负担,线程本身也要占用内存空间,大量的线程会占用内存资源,并且可能会导致OutofMemory,即便没有这样的情况,大量的线程回收也会给GC带来很大的压力,为了避免重复的创建线程线程池的出现可以...
  • Java线程池详解

    万次阅读 多人点赞 2018-04-08 19:07:23
    java中经常需要用到多线程来处理一些业务,我们非常不建议单纯使用继承Thread或者实现Runnable接口的方式来创建线程,那样势必有创建及销毁线程耗费资源、线程上下文切换问题。同时创建过多的线程也会占用过多的内存...
  • 运行 :就绪状态下的线程获取CPU资源后就可以执行run(),此时的线程便处于运行状态,运行状态的线程可变为就绪、阻塞及死亡三种状态。 等待/阻塞/睡眠 :在一个线程执行了sleep(睡眠)、suspend(挂起)等方法后会...
  • 1.新建一个线程工厂类 package cn.yueworld.finance.utils; import java.util.concurrent.ThreadFactory; import java.util.concurrent.atomic.AtomicInteger; public class CommonThreadFactory implements ...
  • 图解Java线程池原理

    2019-08-21 10:11:49
    为了避免频繁重复的创建和销毁线程,我们可以让这些线程进行复用,在线程池中,总会有活跃的线程在占用,但是线程池中也会存在没有占用的线程,这些线程处于空闲状态,当有任务的时候会从池子里面拿去一个线程来进行...
  • 一、前言对于从事后端开发的同学来说,线程是必须要使用了,因为使用它可以提升系统的性能。但是,创建线程和销毁线程都是比较耗时的操作,频繁的创建和销毁线程会浪费很多CPU的资源。此外,如果每...
  • Java线程线程池深入分析(上)

    千次阅读 2019-03-21 08:55:31
    线程池是并发包里面很重要的一部分,在实际情况中也是使用很多的一个重要组件。 下图描述的是线程池API的一部分。广义上的完整线程池可能还包括Thread/Runnable、Timer/TimerTask等部分。这里只介绍主要的和高级...
  • 之前谈过多线程相关的4种常用Java线程锁的特点,性能比较、使用场景,今天主要分享线程池相关的内容,这些都是属于Java面试的必考点。 为什么需要线程池 java中为了提高并发度,可以使用多线程共同执行,但是如果...
  • java线程池的正确使用

    千次阅读 2020-05-15 10:00:01
    首先我们来看一下如下方式存在的问题 new Thread(){ @Override public void run() { super.run(); } }.start(); ...首先频繁的创建、销毁对象是一个很消耗性能的...我们应该使用线程池来统一管理线程的创建与销毁。
  • 它最重要的地方应该就是定义线程名称的格式,便于排查问题。 handler 当没有空闲的线程处理任务(也无法再创建线程了),并且等待队列已满(当然这只对有界队列有效),再有新任务进来的话,就要做一些取舍了,...
  • Java 线程池及参数动态调节详解

    千次阅读 2020-04-16 09:46:28
    前言:曾经自诩对线程池了如指掌,不料看了美团的一篇技术文章后才知道原来线程池的参数还可以动态调节。 经典面试题 在这篇文章中我主要回答上面抛出的这个问题:你这几个参数的值怎么来的呀? 要回答这个问题...
  • public void run() { try { System.out.println(Thread.currentThread().getName()+“启动”); Thread.sleep(100000); System.out.println(Thread....假设线程a b c……按顺序启动,我现在想停下b,如何操作
  • 目录 一、SpringBoot异步线程池 1、定义线程池 2、线程池的使用 ...三、Java线程池 1、使用线程池的优势 2、什么是阻塞队列? 3、线程池为什么要是使用阻塞队列? 4、如何配置线程池? ...
  • 看到这个图片没?没错,就是一辆教练车!我,一个已经工作了好几年大龄暖男,最终还是走上了学车的道路!环顾周围,同事中几乎都手持驾照了。 早上挤出了一小时,练习科目二,前进,后退,...我们想要跟踪下线程..
  • Java线程与高并发八(线程池

    千次阅读 2020-01-23 00:25:40
    Java线程与高并发八给同学们分享下面试中常考的线程池的七大参数! 为什么要用线程池 防止频繁创建和销毁线程,让每个线程可以多次使用,防止消耗过多内存,所以我们使用线程池。 为什么不用JDK自带线程池 像...
  • 1、线程java中是一个对象,更是操作系统的资源,线程创建、销毁都需要时间。 如果创建时间+销毁时间>执行任务时间就很不合算 2、Java对象占用堆内存,操作系统线程占用系统内存,根据JVM规范,一个线程默认最大...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,516
精华内容 14,606
关键字:

java线程池获取线程名称

java 订阅