精华内容
下载资源
问答
  • Java 四种常见线程池解析

    千次阅读 2018-10-05 15:56:55
    目录四种常见线程池ThreadPoolExecutorFixedThreadPoolChachedThreadPoolSingleThreadExecutorScheduledThreadPool 四种常见线程池 线程池用于管理线程的创建与销毁,避免无用线程造成资源浪费,当需要创建多个...


    四种常见线程池


      线程池用于管理线程的创建与销毁,避免无用线程造成资源浪费,当需要创建多个线程时,我们往往需要一个管理者来管理这些线程,这也就引入了线程池的概念.Android中有四种较为常见的线程池也是我们使用最广泛的线程池,FixedThreadPool(固定线程数的线程池),ChachedThreadPool(缓存型线程池),SingleThreadExecutor(单线程线程池),ScheduledThreadPool(周期性调度线程池).这几种线程池本质都是通过ThreadPoolExecutor来创建的.当然在使用中我们只需要通过Executors就能快速创建这几类线程池,但是我们需要理解其创建的具体流程.



    线程池工作流程




    ThreadPoolExecutor

      这四种常见线程池创建的本质都是通过ThreadPoolExecutor来创建的,只是传入的参数不同就生成了不同的线程池,所以我们需要学习ThreadPoolExecutor的构造方法,这样我们就可以创建出符合我们需求的线程池了.

    ThreadPoolExecutor的重要属性

    • corePoolSize:核心线程数,默认情况线程池为空,只有在提交任务后,才会创建新的线程去执行任务,当正在运行的线程数少于核心线程数时,则创建新线程来执行任务;如果等于或者多于核心线程数,则不再创建.如果使用prestartAllcoreThread方法,则会提前创建线程填满线程池,等待任务.
    • maximumPoolSize:线程池允许创建的最大线程数(包括核心线程与非核心线程),如果任务队列已经满了,但是小于maximumPoolSize,仍然可以创建非核心线程来执行任务.
    • keepAliveTime:非核心线程的闲置时间,非核心线程一旦存活时间超过keepAliveTime则会被回收,如果有很多重复任务则可以提高keepAliveTime来保证线程的重复利用率,如果设置了allowCoreThreadTimeOut属性为true.
    • TimeUtil:keepAliveTime的单位,包含天,时,分,秒,毫秒等.
    • WorkQueue:任务队列,这是一个阻塞队列.
    • ThreadFactory:线程工厂,通过线程工厂可以为线程取名,一般无需使用.
    • RejectedExecutionHandler:饱和策略,当任务和线程池都满了时采用的处理方法,默认为AbordPolicy策略表示无法处理新任务.



    饱和策略

      饱和策略就是当任务队列和线程池都已经满了的时候,有新任务进来时采用何种策略来处理新任务.

    • AbordPolicy:表示无法处理新任务
    • CallerRunsPolicy:通过调用者所在线程处理新任务.
    • DiscardPolicy:无法执行新任务,并删除该任务
    • DiscardOldestPolicy:丢弃队列最近的任务并执行该任务.


    FixedThreadPool


      FixedThreadPool的核心线程数和最大线程数都指定为同一值也就意味着,该线程池中只包含了核心线程,并且核心线程数量已经规定好了,其传入的keepAliveTime为0L表示,一旦任务执行完毕,线程空闲就会立即被回收.其传入的任务队列为LinkedBlockingQueue(无界阻塞队列即任务数量没有限制),如果线程多于核心线程数时,任务会被放入任务队列中,等待能创建新线程时再执行.

    使用中我们通过Excutors来创建FixedThreadPool

    Executors.newFixedThreadPool();
    

    FixedThreadPool创建源码

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


    ChachedThreadPool


      ChachedThreadPool线程池中核心线程数为0,其最大线程数为Integer.MAX_VALUE(即无界),这也意味着所有线程都为非核心线程,任务队列为SynchronousQueue(阻塞队列),当任务执行完毕后线程可以存活60秒来等待任务匹配,如果没有任务则被销毁,如果匹配上了任务,则提高了线程的重复利用率.该线程池适用于大量需要立即执行的任务且任务周期较短的任务.

    使用中我们通过Excutors来创建ChachedThreadPool

    Executors.newCachedThreadPool();
    

    ChachedThreadPool创建源码

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


    SingleThreadExecutor


      单线程池,该线程池中只存在一个核心线程,任务队列为LinkedBlockingQueue,即该线程池会把任务放入该无界阻塞队列中一个一个执行.

    使用中我们通过Excutors来创建SingleThreadExecutor

    Executors.newSingleThreadExecutor();
    

    SingleThreadExecutor创建源码

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


    ScheduledThreadPool


      定时调度线程,该线程可以实现延时和周期性循环任务.具有固定的核心线程数以及无界的非核心线程数,任务队列为DelayedWorkQueue(延时队列),DelayedWorkQueue队列会将任务按照顺序排列,将先执行的任务放在队列前端.

    使用中我们通过Excutors来创建ScheduledThreadPool

    Executors.newScheduledThreadPool();
    

    ScheduledThreadPool创建源码

     public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
            return new ScheduledThreadPoolExecutor(corePoolSize);
        }
    

    ScheduledThreadPoolExecutor的构造方法
      这里调用了其super方法,其父类就是ThreadPoolExecutor,所以本质上ScheduledThreadPool也是通过ThreadPoolExecutor创建的.但是有一点不同ScheduledThreadPool的管理队列是一个延时队列,所以它可以定时调度线程.

    public ScheduledThreadPoolExecutor(int corePoolSize) {
            super(corePoolSize, Integer.MAX_VALUE,
                  DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
                  new DelayedWorkQueue());
        }
    

    展开全文
  • 线程池以及四种常见线程池 public ThreadPoolExecutor(int corePoolSize,//核心线程池大小,核心线程将会尽可能地一直活着 int maximumPoolSize,//线程池最大数量包括核心线程数量 long keepAliveTime,//非核心...

    线程池以及四种常见线程池

    public ThreadPoolExecutor(int corePoolSize,//核心线程池大小,核心线程将会尽可能地一直活着
                              int maximumPoolSize,//线程池最大数量包括核心线程数量
                              long keepAliveTime,//非核心线程最长存活时间
                              TimeUnit unit,//keepAliveTime的单位
                              BlockingQueue<Runnable> workQueue,//等待线程的队列
                              ThreadFactory threadFactory,//线程工程
                              RejectedExecutionHandler handler)//线程拒绝执行回调
    复制代码

    四种常见的线程池:

    • Executors.newCachedThreadPool()

      new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                        60L, TimeUnit.SECONDS,
                                        new SynchronousQueue<Runnable>())
      复制代码
    • Executors.newFixedThreadPool(int nThreads)

      new ThreadPoolExecutor(nThreads, nThreads,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>())
      复制代码
    • Executors.newScheduledThreadPool(int nCorepoolSize)

      public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
          return new ScheduledThreadPoolExecutor(corePoolSize);
      }
      
      //ScheduledThreadPoolExecutor():
      public ScheduledThreadPoolExecutor(int corePoolSize) {
          super(corePoolSize, Integer.MAX_VALUE,
                DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
                new DelayedWorkQueue());
      }
      复制代码

    • Executors.newSingleThreadPool()

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

    转载于:https://juejin.im/post/5b690c33e51d4518f5444d81

    展开全文
  • 四种常见线程池解析

    2021-03-09 11:03:44
    线程池线程池的概念四种常见线程池示例代码:示例代码:示例代码:示例代码: 线程池的概念 线程池就是多个线程的集合。使用线程池可以很好地提高性能,线程池在系统启动时即创建大量空闲的线程,程序将一个任务传给...

    一、线程池简介

    1.1线程池概念

    线程池就是多个线程的集合。使用线程池可以很好地提高性能,线程池在系统启动时即创建大量空闲的线程,程序将一个任务传给线程池,线程池就会启动一条线程来执行这个任务,执行结束以后,该线程并不会死亡,而是再次返回线程池中成为空闲状态,等待执行下一个任务。

    1.2线程池优势

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

    1.3线程池主要参数

    1.corePoolSize(线程池基本大小):当向线程池提交一个任务时,若线程池已创建的线程数小于corePoolSize,即便此时存在空闲线程,也会通过创建一个新线程来执行该任务,直到已创建的线程数大于或等于corePoolSize时,(除了利用提交新任务来创建和启动线程(按需构造),也可以通过 prestartCoreThread() 或 prestartAllCoreThreads() 方法来提前启动线程池中的基本线程。)

    2.maximumPoolSize(线程池最大大小):线程池所允许的最大线程个数。当队列满了,且已创建的线程数小于maximumPoolSize,则线程池会创建新的线程来执行任务。另外,对于无界队列,可忽略该参数。

    3.keepAliveTime(线程存活保持时间)当线程池中线程数大于核心线程数时,线程的空闲时间如果超过线程存活时间,那么这个线程就会被销毁,直到线程池中的线程数小于等于核心线程数。

    4.workQueue(任务队列):用于传输和保存等待执行任务的阻塞队列。

    5.threadFactory(线程工厂):用于创建新线程。threadFactory创建的线程也是采用new Thread()方式,threadFactory创建的线程名都具有统一的风格:pool-m-thread-n(m为线程池的编号,n为线程池内的线程编号)。

    6.handler(线程饱和策略):当线程池和队列都满了,再加入线程会执行此策略。

    二、四种常见线程池

    ExecutorService类
    ExecutorService类由Java提供的用于管理线程池,该类的两个作用是控制线程数量和重用线程。

    四种常用线程池实现如下(返回值都是ExecutorService)
    1.Executors.newCacheThreadPool():可缓存线程池,先查看池中有没有以前建立的线程,如果有,就直接使用。如果没有,就建一个新的线程加入池中,缓存型池子通常用于执行一些生存期很短的异步型任务。

    示例代码:

    package com.channelPool.test;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class NewCachedThreadPoolTest {
        public static void main(String[] args) {
            // 创建一个cached线程池
            ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
            for (int i = 0; i < 5; i++) {
                try {
                    // sleep可明显看到没有创建新的线程,使用的线程都是以前线程池中存在的
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                cachedThreadPool.execute(new Runnable() {
                    public void run() {
                        // 打印正在执行的缓存线程信息
                        System.out.println(Thread.currentThread().getName()
                                + "正在被执行");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
    

    输出结果:

    pool-1-thread-1正在被执行
    pool-1-thread-1正在被执行
    pool-1-thread-1正在被执行
    pool-1-thread-1正在被执行
    pool-1-thread-1正在被执行

    如果线程池无限大,执行当前任务的上一个任务已经完成则会复用上一个任务,而不是创建一个新的线程。

    2.Executors.newFixedThreadPool(int n):创建一个可重用固定个数的线程池,以共享的无界队列方式来运行这些线程。

    示例代码:

    package com.channelPool.test;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class NewFixedThreadPoolTest {
    
        public static void main(String[] args) {
            // 创建一个可重用固定个数的线程池
            ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
            for (int i = 0; i < 9; i++) {
                fixedThreadPool.execute(new Runnable() {
                    public void run() {
                        try {
                            // 打印正在执行的缓存线程信息
                            System.out.println(Thread.currentThread().getName()
                                    + "正在被执行");
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
    }
    

    输出结果:

    pool-1-thread-1正在被执行
    pool-1-thread-2正在被执行
    pool-1-thread-3正在被执行
    pool-1-thread-4正在被执行
    pool-1-thread-1正在被执行
    pool-1-thread-2正在被执行
    pool-1-thread-3正在被执行
    pool-1-thread-4正在被执行
    pool-1-thread-1正在被执行

    线程池的大小为4,每个任务输出打印后都会sleep2秒所以每过两秒就打印4个结果。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。

    3.Executors.newScheduledThreadPool(int n):创建一个定长线程池,支持定时及周期性任务执行。

    示例代码:

    package com.channelPool.test;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    public class NewScheduledThreadPoolTest {
    
        public static void main(String[] args) {
                     //创建一个定长线程池,支持定时及周期性任务执行——延迟执行
                     ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
                     //延迟执行
                     //延迟1秒执行
                     scheduledThreadPool.schedule(new Runnable() {
                         public void run() {
                            System.out.println("延迟1秒执行");
                         }
                     }, 1, TimeUnit.SECONDS);
                     
                     //定期执行
                     //延迟1秒后每3秒执行一次
                     scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
                         public void run() {
                             System.out.println("延迟1秒后每3秒执行一次");
                         }
                    }, 1, 3, TimeUnit.SECONDS);
                 } 
    }
    

    延时执行输出结果:延迟1秒执行
    定期执行输出结果:延迟1秒后每3秒执行一次

    4.Executors.newSingleThreadExecutor():创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

    示例代码:

    package com.channelPool.test;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class NewSingleThreadExecutorTest {			
    
    	public static void main(String[] args) {		          
    			//创建一个单线程化的线程池		          
    			ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();	
    			for (int i = 0; i < 10; i++) {		         					  				            
    				 final int index = i;		             
    				 singleThreadExecutor.execute(new Runnable() {		                 
    				 	public void run() {		                    
    				 		try {		                         
    				 		//结果依次输出,相当于顺序执行各个任务	
    			System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);	
    					Thread.sleep(5000);					                         					                         		                     
    							} 
    						catch (InterruptedException e) {
    							e.printStackTrace();		                     
    						}		                 
    					}		             
    				});		         
    			}		     
    		}
    	}
    

    输出结果:

    pool-1-thread-1正在被执行,打印的值是:0
    pool-1-thread-1正在被执行,打印的值是:1
    pool-1-thread-1正在被执行,打印的值是:2
    pool-1-thread-1正在被执行,打印的值是:3
    pool-1-thread-1正在被执行,打印的值是:4
    pool-1-thread-1正在被执行,打印的值是:5
    pool-1-thread-1正在被执行,打印的值是:6
    pool-1-thread-1正在被执行,打印的值是:7
    pool-1-thread-1正在被执行,打印的值是:8
    pool-1-thread-1正在被执行,打印的值是:9

    参考链接:
    [https://www.cnblogs.com/jiawen010/p/11855768.html]

    展开全文
  • Java中的常见线程池

    2021-07-26 21:43:33
    目录Java中的常见线程池类型区别使用 不积跬步,无以至千里;不积小流,无以成江海。要沉下心来,诗和远方的路费真的很贵! Java中的常见线程池 类型 newCacheThreadPool newFixedThreadPool newSingleThreadPool ...


    不积跬步,无以至千里;不积小流,无以成江海。要沉下心来,诗和远方的路费真的很贵!

    Java中的常见线程池

    类型

    • newCacheThreadPool
    • newFixedThreadPool
    • newSingleThreadPool
    • newScheduleThreadPool

    区别

    1. newCacheThreadPool
    • 是一个拥有缓存的线程池,将每一个线程缓存起来(缓存释放时间默认为工作线程空闲一分钟),工作线程数量是无限大。
    1. newFixedThreadPool
    • 创建线程池的时候固定最大工作线程,当任务多的时候,工作线程达到上限,任务进入等待队列,等待某一个线程执行完。
    1. newSingleThreadPool
    • 保证线程池中只有一个工作线程,任务顺序执行。
    1. newScheduleThreadPool
    • 可以执行定时,延迟,周期性任务。

    使用

    1. newCacheThreadPool

    可缓存的线程池。将线程缓存起来,复用线程,减少资源的消耗。当上一个任务结束后,复用当前线程去执行任务。以下十个任务,循环进行执行,所以复用线程,都是一个线程执行。

    package com.hnucm;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Main {
    	public static void main(String[] args) {
    		//创建可缓存线程池
    		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    		for (int i = 0; i < 10; i++) {
    			try {
    				// sleep可明显看到使用的是线程池里面以前的线程,没有创建新的线程
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			//线程池持续任务
    			cachedThreadPool.execute(new Runnable() {
    				@Override
    				public void run() {
    					// 打印正在执行的缓存线程信息
    					System.out.println(Thread.currentThread().getName() + "正在执行");			}
    			});
    		}
    	}
    }
    

    在这里插入图片描述
    2. newFixedThreadPool

    固定工作线程的数量,多个线程并发执行任务,所以不能确定执行顺序。以下所以是三个线程同时执行。

    package com.hnucm;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Main {
    	public static void main(String[] args) {
    		//创建固定线程池
    		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    		for (int i = 0; i < 10; i++) {
                fixedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                        	//同步执行三个任务
                        	//三个工作线程
                            //打印正在执行的缓存线程信息
                            System.out.println(Thread.currentThread().getName()+"正在被执行");
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
    	}
    }
    

    在这里插入图片描述
    3. newSingleThreadPool

    单线程的线程池。只有一个工作线程,确保执行任务时,其他任务等待,确保任务顺序执行。

    package com.hnucm;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Main {
    	public static void main(String[] args) {
    		//创建单工作线程线程池
    		ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
    		for (int i = 0; i < 10; i++) {
    			//常量
                final int index = i;
                singleThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            //结果依次输出,相当于顺序执行各个任务
                        	//第i个任务
                            System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
    	}
    }
    

    在这里插入图片描述
    4. newScheduleThreadPool

    定长的线程池。用于执行延迟,定时,周期性任务。

    • 延迟执行
    package com.hnucm;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    public class Main {
    	public static void main(String[] args) {
    		//创建一个定长线程池,支持定时及周期性任务执行——延迟执行
            ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
            //延迟1秒执行
            scheduledThreadPool.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("延迟5秒执行");
                }
            }, 5, TimeUnit.SECONDS);
    	}
    }
    
    • 延迟+定期(周期)执行
    package com.hnucm;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    public class Main {
    	public static void main(String[] args) {
    		//创建一个定长线程池,支持定时及周期性任务执行——延迟执行
            ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
            //延迟1秒执行
            scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println("延迟1秒后每3秒执行一次");
                }
            }, 1, 3, TimeUnit.SECONDS);
    	}
    }
    

    在这里插入图片描述

    展开全文
  • 常见线程池学习小结

    2021-08-02 10:50:17
    目录1、创建一个线程池的基本方法1.1、参数解释1.2、方法说明2、几种常见线程池总结2.1、CachedThreadPool2.1.1、参数2.1.2、特点2.2、FixedThreadPool2.2.1、参数2.2.2、特点2.3、SingleThreadExecutor2.3.1、参数...
  • 常见线程池和启动定时器线程池 1.线程池的概念:线程池是一种多线程处理形式,处理过程中将任务添加到队列,如果线程池中有空闲的线程,则由该线程去完成这些任务。 2.Excecutors类的应用  (1)创建固定大小的...
  • java中四种常见线程池

    2019-06-04 15:52:47
    java中四种常见线程池 Java通过Executors类提供四种线程池,我们查看源码可以知道,这四种线程池内部都是基于ThreadPoolExecutor类(Executor的子类)实现的。分别为: newCachedThreadPool 创建一个可缓存...
  • 深入浅出多线程编程实战(七)六种常见线程池讲解 文章目录一、线程池介绍二、java常用线程池关系1.六种常用线程池2.类图及主要方法三.线程池实现类讲解1.FixedThreadPool2.SingleThreadExecutor3.CachedThreadPool...
  • 常见线程池 本质都是ThreadPoolExecutor 注意事项 常见线程池 a、newFixedThreadPool 创建一个固定长度的线程池,当到达线程最大数量时,线程池的规模将不再变化。 b、newCachedThreadPool 创建一个可...
  • 常见线程池种类

    千次阅读 2019-11-08 09:30:15
    创建固定线程数的线程池,使用的是LinkedBlockingQueue无界队列,线程池中实际线程数永远不会变化 适用于可以预测线程数量的业务中,或者服务器负载较重,对线程数有严格限制的场景 Executors....
  • 本文将讲解线程池参数、参数之间的关系以及线程池以一个怎么样的策略执行新增到线程池的线程,最后会举例常见线程池是怎么样应用这些参数和流程的。文章较长,可以根据目录选择想看的知识,若有错误请指出。 1....
  • Java常见线程池

    2019-02-16 14:14:43
    1. 为什么使用线程池 诸如 Web 服务器、数据库服务器、文件服务器或邮件服务器之类的许多服务器应用程序都面向处理来自某些远程来源的大量短小的任务。请求以某种方式到达服务器,这种方式可能是通过网络协议(例如 ...
  • Executors类创建四种常见线程池

    千次阅读 多人点赞 2019-10-14 09:45:18
    文章目录线程池架构newSingleThreadExecutornewFixedThreadPoolnewCachedThreadPoolnewScheduledThreadPoolExecutors和ThreaPoolExecutor创建线程池的区别两种提交任务的方法executesubmit 线程池架构 上图是线程池...
  • 常见线程池的使用

    2021-05-01 19:42:03
    为什么使用线程池 1.如果我们需要很多线程,并且线程执行任务的时间又短的时候。我们需要完成这些过程创建任务,创建线程,线程执行,关闭线程。而这些过程中创建线程和关闭线程会占用大量的时间和资源。 2.所以就有...
  • 线程池 概念 线程池就是首先创建一些线程,他们的集合称为线程池,使用线程池可以很好的提高性能。 5种状态 ThreadPoolExecutor 使用int的高3位来表示线程池状态,低29位表示线程数量 状态名 高3位 说明 ...
  • java线程池原理 Executors类提供了FixedThreadPool、CachedThreadPool等线程池对象,都是基于ThreadPoolExecutor产生的。 Executor接口定义了execute(),子接口ExecutorService又定义了submit(),抽象类...
  • java线程池总结ThreadPoolExecutor线程池线程池的4个构造方法。`ThreadPoolExecutor`的策略参数实例解释**阻塞队列` BlockingQueue workQueue`**`SynchronousQueue``ArrayBlockingQueue``LinkedBlockingQueue``...
  • newFixedThreadPool:创建固定大小的线程池,每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小; newCachedThreadPool:创建一个可缓存的线程池,此线程池不会对线程池大小做限制,线程池大小完全依赖...
  • 传统的多线程缺点: 每次新建/销毁线程对象消耗资源、响应速度慢。 线程缺乏统一管理,容易出现阻塞的情况。...常见的4类线程池 Executor是一个接口,线程池中的真正实现者:ThreadPoolExecutor。 Androi...
  • 什么是阻塞队列线程池的工作队列线程池执行流程几种常见线程池newFixedThreadPoolnewCachedThreadPoolnewSingleThreadExecutornewScheduledThreadPool底层原理参数简介饱和拒绝策略创建线程池什么是死锁手写一个...
  • 四种常见线程池

    2018-01-03 23:54:00
    //缓存线程池线程池的大小由jvm决定,如果有空闲线程会回收 Executors.newCachedThreadPool(); //单线程线程池,可保证任务执行的顺序就是任务提交的顺序 Executors.newSingleThreadExecutor(); //固定...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,612
精华内容 33,044
关键字:

常见线程池