❶ java线程池的理解
线程池顾名思义是一个装着"线程"的池子,,它包含了很多已经启动好的并且处于睡眠状态的线程.当你有请求时,就会直接使用池子里面的线程而不用去创建.对于请求量很少的时候看起来没多少作用...但是当系统使用人数多了..请求数量很多的时候就会为系统节约大量的资源,让系统不去忙于线程的创建和销毁,,,而让系统更好的完成他的功能.
❷ java线程池有哪些
一：newCachedThreadPool
(1)缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse，如果没有，就建立一个新的线程加入池中；
(2)缓存型池子，通常用于执行一些生存周期很短的异步型任务；因此一些面向连接的daemon型server中用得不多；
(3)能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s,超过这个IDLE时长，线程实例将被终止及移出池。
(4)注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止
二：newFixedThreadPool
(1)newFixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程
(2)其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子
(3)和cacheThreadPool不同，FixedThreadPool没有IDLE机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的），所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器
(4)从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同:
fixed池线程数固定，并且是0秒IDLE（无IDLE）
cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力），60秒IDLE
三：ScheledThreadPool
（1）调度型线程池
（2）这个池子里的线程可以按schele依次delay执行，或周期执行
四：SingleThreadExecutor
（1）单例线程，任意时间池中只能有一个线程
（2）用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE）
❸ java线程池怎么实现的
多线程技术主要解决处理器单元内多个线程执行的问题，它可以显着减少处理器单元的闲置时间，增加处理器单元的吞吐能力。
假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。
如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。
一个线程池包括以下四个基本组成部分：
1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；
2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；
3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。
线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。
线程池不仅调整T1,T3产生的时间段，而且它还显着减少了创建线程的数目，看一个例子：
假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。
代码实现中并没有实现任务接口，而是把Runnable对象加入到线程池管理器（ThreadPool），然后剩下的事情就由线程池管理器（ThreadPool）来完成了
packagemine.util.thread;
importjava.util.LinkedList;
importjava.util.List;
/**
*线程池类，线程管理器：创建线程，执行任务，销毁线程，获取线程基本信息
*/
publicfinalclassThreadPool{
//线程池中默认线程的个数为5
privatestaticintworker_num=5;
//工作线程
privateWorkThread[]workThrads;
//未处理的任务
_task=0;
//任务队列，作为一个缓冲,List线程不安全
privateList<Runnable>taskQueue=newLinkedList<Runnable>();
;
//创建具有默认线程个数的线程池
privateThreadPool(){
this(5);
}
//创建线程池,worker_num为线程池中工作线程的个数
privateThreadPool(intworker_num){
ThreadPool.worker_num=worker_num;
workThrads=newWorkThread[worker_num];
for(inti=0;i<worker_num;i++){
workThrads[i]=newWorkThread();
workThrads[i].start();//开启线程池中的线程
}
}
//单态模式，获得一个默认线程个数的线程池
(){
returngetThreadPool(ThreadPool.worker_num);
}
//单态模式，获得一个指定线程个数的线程池,worker_num(>0)为线程池中工作线程的个数
//worker_num<=0创建默认的工作线程个数
(intworker_num1){
if(worker_num1<=0)
worker_num1=ThreadPool.worker_num;
if(threadPool==null)
threadPool=newThreadPool(worker_num1);
returnthreadPool;
}
//执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定
publicvoidexecute(Runnabletask){
synchronized(taskQueue){
taskQueue.add(task);
taskQueue.notify();
}
}
//批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定
publicvoidexecute(Runnable[]task){
synchronized(taskQueue){
for(Runnablet:task)
taskQueue.add(t);
taskQueue.notify();
}
}
//批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定
publicvoidexecute(List<Runnable>task){
synchronized(taskQueue){
for(Runnablet:task)
taskQueue.add(t);
taskQueue.notify();
}
}
//销毁线程池,该方法保证在所有任务都完成的情况下才销毁所有线程，否则等待任务完成才销毁
publicvoiddestroy(){
while(!taskQueue.isEmpty()){//如果还有任务没执行完成，就先睡会吧
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
//工作线程停止工作，且置为null
for(inti=0;i<worker_num;i++){
workThrads[i].stopWorker();
workThrads[i]=null;
}
threadPool=null;
taskQueue.clear();//清空任务队列
}
//返回工作线程的个数
publicintgetWorkThreadNumber(){
returnworker_num;
}
//返回已完成任务的个数,这里的已完成是只出了任务队列的任务个数，可能该任务并没有实际执行完成
(){
returnfinished_task;
}
//返回任务队列的长度，即还没处理的任务个数
publicintgetWaitTasknumber(){
returntaskQueue.size();
}
//覆盖toString方法，返回线程池信息：工作线程个数和已完成任务个数
@Override
publicStringtoString(){
return"WorkThreadnumber:"+worker_num+"finishedtasknumber:"
+finished_task+"waittasknumber:"+getWaitTasknumber();
}
/**
*内部类，工作线程
*/
{
//该工作线程是否有效，用于结束该工作线程
privatebooleanisRunning=true;
/*
*关键所在啊，如果任务队列不空，则取出任务执行，若任务队列空，则等待
*/
@Override
publicvoidrun(){
Runnabler=null;
while(isRunning){//注意，若线程无效则自然结束run方法，该线程就没用了
synchronized(taskQueue){
while(isRunning&&taskQueue.isEmpty()){//队列为空
try{
taskQueue.wait(20);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
if(!taskQueue.isEmpty())
r=taskQueue.remove(0);//取出任务
}
if(r!=null){
r.run();//执行任务
}
finished_task++;
r=null;
}
}
//停止工作，让该线程自然执行完run方法，自然结束
publicvoidstopWorker(){
isRunning=false;
}
}
}
❹ java线程池（一） 简述线程池的几种使用方式
首先说明下java线程是如何实现线程重用的
1. 线程执行完一个Runnable的run()方法后，不会被杀死
2. 当线程被重用时，这个线程会进入新Runnable对象的run()方法12
java线程池由Executors提供的几种静态方法创建线程池。下面通过代码片段简单介绍下线程池的几种实现方式。后续会针对每个实现方式做详细的说明
newFixedThreadPool
创建一个固定大小的线程池
添加的任务达到线程池的容量之后开始加入任务队列开始线程重用总共开启线程个数跟指定容量相同。
@Test
public void newFixedThreadPool() throws Exception {
ExecutorService executorService = Executors.newFixedThreadPool(1);
executorService = Executors.newFixedThreadPool(1, new ThreadFactoryBuilder().build());
RunThread run1 = new RunThread("run 1");
executorService.execute(run1);
executorService.shutdown();
}12345678
newSingleThreadExecutor
仅支持单线程顺序处理任务
@Test
public void newSingleThreadExecutor() throws Exception {
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();
}123456789
newCachedThreadPool
这种情况跟第一种的方式类似，不同的是这种情况线程池容量上线是Integer.MAX_VALUE 并且线程池开启缓存60s
@Test
public void newCachedThreadPool() throws Exception {
ExecutorService executorService = Executors.newCachedThreadPool();
executorService = Executors.newCachedThreadPool(new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();
}123456789
newWorkStealingPool
支持给定的并行级别，并且可以使用多个队列来减少争用。
@Test
public void newWorkStealingPool() throws Exception {
ExecutorService executorService = Executors.newWorkStealingPool();
executorService = Executors.newWorkStealingPool(1);
RunThread run1 = new RunThread("run 1");
executorService.execute(run1);
executorService.shutdown();
}123456789
newScheledThreadPool
看到的现象和第一种相同，也是在线程池满之前是新建线程，然后开始进入任务队列，进行线程重用
支持定时周期执行任务(还没有看完)
@Test
public void newScheledThreadPool() throws Exception {
ExecutorService executorService = Executors.newScheledThreadPool(1);
executorService = Executors.newScheledThreadPool(1, new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();
}
❺ Java有多少种线程池
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
newFixedThreadPool创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
。newScheledThreadPool创建一个定长线程池，支持定时和周期性任务执行
newSingleThreadExecutor创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序（FIFO，LIFO，优先级）执行。
❻ java 什么是线程池及为什么要使用线程池
创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变长，而且一个进程能创建的线程数有限。为了避免这些问题，在程序启动的时候就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程。从JDK1.5开始，Java API提供了Executor框架让你可以创建不同的线程池。比如单线程池，每次处理一个任务；数目固定的线程池或者是缓存线程池（一个适合很多生存期短的任务的程序的可扩展线程池）。
❼ java的四种线程池哪个比较好
无法简单的说那个线程好，应该说适合用那个线程，这里有比较详细的介绍java的四种线程池，可以根据需求使用线程池。
http://blog.csdn.net/u011974987/article/details/51027795
❽ 什么是java线程池
多线程是为了能够让计算机资源合理的分配，对于处理不同的任务创建不同的线程进行处理，但是计算机创建一个线程或者销毁一个线程所花费的也是比较昂贵的，有时候需要同时处理的事情比较多，就需要我们频繁的进行线程的创建和销毁，这样花费的时间也是比较多的。为了解决这一问题，我们就可以引用线程池的概念。
所谓线程池就是将线程集中管理起来，当需要线程的时候，可以从线程池中获取空闲的线程，这样可以减少线程的频繁创建与销毁，节省很大的时间和减少很多不必要的操作。
在java中提供了ThreadPoolExecutor类来进行线程的管理，这个类继承于AbstractExecutorService，而AbstractExecutorService实现了ExecutorService接口，我们可以使用ThreadPoolExecutor来进行线程池的创建。
在ThreadPoolExecutor的构造方法中，有多个参数，可以配置不同的参数来进行优化。这个类的源码构造方法为：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)其中每个参数代表的意义分别为
corePoolSize : 线程池中的核心线程数量，当线程池中当前的线程数小于这个配置的时候，如果有一个新的任务到来，即使线程池中还存在空闲状态的线程，程序也会继续创建一个新的线程放进线程池当中
maximumPoolSize: 线程池中的线程最大数量
keepAliveTime：当线程池中的线程数量大于配置的核心线程数量(corePoolSize)的时候，如果当前有空闲的线程，则当这个空闲线程可以存在的时间，如果在keepAliveTime这个时间点内没有新的任务使用这个线程，那么这个线程将会结束,核心线程不会结束，但是如果配置了allowCoreThreadTimeOut = true，则当空闲时间超过keepAliveTime之后，线程也会被结束调，默认allowCoreThreadTimeOut = false，即表示默认情况下，核心线程会一直存在于线程池当中。
unit : 空闲线程保持连接时间(keepAliveTime)的时间单位
workQueue：阻塞的任务队列，用来保存等待需要执行的任务。
threadFactory ：线程工厂，可以根据自己的需求去创建线程的对象，设置线程的名称，优先级等属性信息。
handler：当线程池中存在的线程数超过设置的最大值之后，新的任务就会被拒绝，可以自己定义一个拒绝的策略，当新任务被拒绝之后，就会使用hander方法进行处理。
在java中也提供了Executors工具类，在这个工具类中提供了多个创建线程池的静态方法，其中包含newCachedThreadPool、newFixedThreadPool、newScheledThreadPool、newSingleThreadExecutor等。但是他们每个方法都是创建了ThreadPoolExecutor对象，不同的是，每个对象的初始 参数值不一样;
❾ java使用线程池的方式
参考举例：
packagecom.journaldev.threadpool;
{
privateStringcommand;
publicWorkerThread(Strings){
this.command=s;
}
@Override
publicvoidrun(){
System.out.println(Thread.currentThread().getName()+"Start.Command="+command);
processCommand();
System.out.println(Thread.currentThread().getName()+"End.");
}
privatevoidprocessCommand(){
try{
Thread.sleep(5000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
@Override
publicStringtoString(){
returnthis.command;
}
}
publicstaticvoidmain(String[]args){
ExecutorServiceexecutor=Executors.newFixedThreadPool(5);for(inti=0;i<10;i++){
Runnableworker=newWorkerThread(""+i);
executor.execute(worker);
}
executor.shutdown();while(!executor.isTerminated()){
}
System.out.println("Finishedallthreads");
}