线程池参数setsession有什么用

本文基础语言java。

1、传统新建线程的两种方式：

（1）new Thread 对象继承Thread的时候。

public class ThreadTest2 extends Thread {
    private int threadCnt = 10;

    @Override
    public void run() {
        while (true) {
            if (threadCnt > 0) {
                System.out.println(Thread.currentThread().getName() + " 剩余个数 " + threadCnt);
                threadCnt--;
                try {
                    Thread.sleep(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                break;
            }
        }
    }

    public static void main(String[] args) {
        new ThreadTest2().start();
        new ThreadTest2().start();
    }
}

（2）、对象在实现runnable 方法的时候

public class RunnalbleTest2 implements Runnable {
    private int threadCnt = 10;

    @Override
    public void run() {
        while (true) {
            if (threadCnt > 0) {
                System.out.println(Thread.currentThread().getName() + " 剩余个数 " + threadCnt);
                threadCnt--;
                try {
                    Thread.sleep(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                break;
            }
        }
    }

    public static void main(String[] args) {
        RunnalbleTest2 runnalbleTest2 = new RunnalbleTest2();
        new Thread(runnalbleTest2).start();
        new Thread(runnalbleTest2).start();
        new Thread(runnalbleTest2).start();
        new Thread(runnalbleTest2).start();
    }
}

new Thread在并发编程中有很多劣势：
a.每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。

java 四种常用的线程池

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

下面是Java提供常用四种线程池。
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

（1）newCachedThreadPool：
可以缓冲的线程池，如果线程池的长度超过处理的需要。可以灵活的回收空闲线程，如果没有可以回收的线程，则需要新建线程。具体的实现方式为：

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    for (int i = 0; i < 10; i++) {
        final int index = i;
    try {
        Thread.sleep(index * 1000);
    } 
        catch (InterruptedException e) {
            e.printStackTrace();
    }

cachedThreadPool.execute(new Runnable() {

@Override
public void run() {
    System.out.println(index);
}
});
}

另一种实现方式为：

package app.executors;  

import java.util.concurrent.Executors;  
import java.util.concurrent.ExecutorService;  

/** 

 */  
public class Test {  
    public static void main(String[] args) {  
        // 创建一个可重用固定线程数的线程池  
        ExecutorService pool = Executors.newCachedThreadPool();  
        // 创建线程  
        Thread t1 = new MyThread();  
        Thread t2 = new MyThread();  
        Thread t3 = new MyThread();  
        Thread t4 = new MyThread();  
        Thread t5 = new MyThread();  
        // 将线程放入池中进行执行  
        pool.execute(t1);  
        pool.execute(t2);  
        pool.execute(t3);  
        pool.execute(t4);  
        pool.execute(t5);  
        // 关闭线程池  
        pool.shutdown();  
    }  
}  

class MyThread extends Thread {  
    @Override  
    public void run() {  
        System.out.println(Thread.currentThread().getName() + "正在执行。。。");  
    }  
}

注意：此线程池特点为创建一个可缓存的线程池，如果线程池的大小超过了处理任务需要的的线程时，（此时说明线程池中的线程大于任务所需的线程），线程池会启动回收机制，回收策略为将60秒内不执行任务的线程回收。而当任务数量增加时，此时线程池又可以智能的添加新线程来处理任务，此线程不会对线程池的线程数做大小限制，线程池可以创建线程的多少依赖于操作系统（或者说JVM）能够创建的最大线程大小。

（2）、newFixedThreadPool：
创建一个定长线程池，可以控制线程的最大并发数量。超出的线程会加入到队列中进行等待。开发的实例代码为：
（创建时可以指定线程池的长度如下3）

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    for (int i = 0; i < 10; i++) {
    final int index = i;

    fixedThreadPool.execute(new Runnable() {

@Override
public void run() {
try {
    System.out.println(index);
    Thread.sleep(2000);
} catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
}
});
}

另一种参考如上完成

注意：创建固定长度的线程池的特点为，每次提交一个任务都回创建一个线程。直到线程数量达到线程池的最大长度，线程池的大小一旦到达最大，线程池的线程的个数就不会减少。如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。定长线程池的大小最好根据系统资源进行限制 。如Runtime.getRuntime().availableProcessors()、可参考PreloadDataCache。 todo

（3）、newScheduledThreadPool：
此线程池是上面的变形，也是创建一个定长线程池，并支持定时及周期性的任务执行，先吃执行的代码如下。（延迟三秒执行）

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
 scheduledThreadPool.schedule(new Runnable() {

@Override
public void run() {
    System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);

定期执行示例代码如下（）延迟1秒后每3秒执行一次

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

@Override
public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);

方式二：

public class TestScheduledThreadPoolExecutor {

    public static void main(String[] args) {

        ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);

        exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间就触发异常

                      @Override

                      publicvoid run() {

                           //throw new RuntimeException();

                           System.out.println("================");

                      }

                  }, 1000, 5000, TimeUnit.MILLISECONDS);

        exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间打印系统时间，证明两者是互不影响的

                      @Override

                      publicvoid run() {

                           System.out.println(System.nanoTime());

                      }

                  }, 1000, 2000, TimeUnit.MILLISECONDS);

    }

}

注意：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。此线程池功能加上了定时调度的功能很多时候比Timer 定时调度功能更安全、强大

(4)、newSingleThreadExecutor：
创建一个单一的线程化的线程池，它只会用唯一的工作线程来执行任务。保证任务按照指定顺序（FiFO、LIFO、优先级）执行，事例代码：

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {

@Override
public void run() {
    try {
        System.out.println(index);
    Thread.sleep(2000);
} catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
        }
}
    });
}

注意：上面的任务相当于顺序执行各个任务，他是一个单线程的线程池。这个线程只有运行一个线程在工作，相当于任务的单线程顺序的串行执行。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

总结：
线程池作用就是限制系统中执行线程的数量。 根 据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列中取最前面任务开始执行，如果队列中没有等待线程，线程池这一资源处于等待，当一个新任务需要运行时，如果线程池 中有等待的工作线程，就可以开始运行了；否则进入等待队列。
工作中应用线程池的优势：（1）减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。（2）可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。