线程池

线程池：

　　什么是线程池呢？线程池就是线程的容器，线程池就是首先创建一些线程，它们的集合称为线程池。主要用来管理线程的，使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

什么时候使用线程？

当程序中要创建大量生存期很短的线程时，应该考虑使用线程池，程序启动一个新线程占用资源大，会过渡消耗系统资源，以及过渡切换线程的危险，从而可能导致系统资源的崩溃。这时，线程池就是最好的选择了。

代码示例如下：

package com.ccv.cn;
​
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
​
public class ThreadDemo05 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
    //创建线程池
    ExecutorService espool = Executors.newFixedThreadPool(3);
    //将线程放入池中
    espool.submit(new ThstRunnable());
    Future<Integer> future = espool.submit(new ThstCallable());
    espool.submit(new Runnable() {
        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            for (int i = 0; i <=50; i++) {
                System.out.println(Thread.currentThread().getName() + "实现Runnable开启线程" + i);
            }
            
        }
    });
    System.out.println("和为：" + future.get());
    //结束线程
    espool.shutdown();
}
}
//创建ThstRunnable类实现Runnable接口
class ThstRunnable implements Runnable {
    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
                    System.out.println(Thread.currentThread().getName() + "实现Runnable开启线程" + i);
        }
    }
​
}
//创建ThstCallable类实现Callable接口
class ThstCallable implements Callable<Integer> {
    //重写run方法
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <=50; i++) {
            System.out.println(Thread.currentThread().getName() + "实现Callable开启线程" + i);    
            sum += i;
        }
        return sum;
    }
    
}

java中的线程构造方法：

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

示例代码如下：

package com.ccv.cn;
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadDemo09 {
    public static void main(String[] args) {
        //使用newSingleThreadExecutor() 方法创建一个单线程化的线程池
         ExecutorService stp = Executors.newSingleThreadExecutor();
         for (int i = 1; i < 30; i++) {
             final int a = i;
            stp.execute(new Runnable() {
            //重写run方法
            @Override
            public void run() {
                try {
                    //依次输出结果
                    System.out.println(Thread.currentThread().getName() + "匿名内部类实现Runnable开启线程" + a);
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}
}

2、newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

示例代码如下：

package com.ccv.cn;
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
​
public class ThreadDemo06 {
public static void main(String[] args) {
    // TODO Auto-generated method stub
    //使用newCachedThreadPool() 方法创建线程池
    ExecutorService ctp = Executors.newCachedThreadPool();
    for (int i = 0; i <=30; i++) {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        ctp.execute(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println(Thread.currentThread().getName() + "匿名内部类实现Runnable开启线程" );
                
            }
        });
    }
​
}
}

3、newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

示例代码如下：

package com.ccv.cn;
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
​
public class ThreadDemo07 {
public static void main(String[] args) {
    //使用newFixedThreadPool() 方法创建一个可定长线程池
     ExecutorService ftp = Executors.newFixedThreadPool(5);
     for (int i = 0; i < 30; i++) {
        ftp.execute(new Runnable() {
            //重写run方法
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "匿名内部类实现Runnable开启线程");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}
}

4、newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

示例代码如下：

package com.ccv.cn;
​
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
​
public class ThreadDemo08 {
public static void main(String[] args) {
    // 使用newScheduledThreadPool创建一个定长线程池，可延迟执行
    ScheduledExecutorService stp = Executors.newScheduledThreadPool(5);
    
    stp.schedule(new Runnable() {
        
        @Override
        public void run() {
            System.out.println("匿名内部类实现Runnable开启线程:延迟3秒");
        }
        //下面是延迟和被执行时间
    }, 3, TimeUnit.SECONDS);
}
}