线程(Thread) -- 线程池实现

实现线程的方式有四种：
方式一：定义类继承Thread类
方式二：定义类实现Runnable接口
方式三：定义类实现Callable接口
第四种便是通过线程池来实现,线程池顾名思义，就是一个载有线程的容器。它提供了一个线程集合，队列中的所有线程都保存着等待状态，当要执行任务时候，线程池中的线程就会被分配任务，任务一旦完成，线程回到线程池中处于等待状态，这样避免了创建和销毁额外的开销，提高了响应的速度。
如下是线程池的体系结构(在java.util.concurrent包中)：
|-- Executor:负责线程的使用与调度的根接口
  |-- ExecutorService 子接口：线程池的主要接口
    |-- ThreadPoolExecutor 线程池的实现类
    |-- ScheduledExecutorService 子接口：负责线程的调度
      |-- ScheduledThreadPoolExecutor ：继承 ThreadPoolExecutor，实现 ScheduledExecutorService
从API文档中查看Executor接口可知：Executors类提供了方便的工厂方法用于创建线程等。
例如：
staitc ExecutorService newFixedThreadPool(int nThreads):创建固定大小的线程池
staitc ExecutorService newCachedThreadPool():缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量
static ExecutorService newSingleThreadExecutor():创建单个线程池，线程池中只有一个线程
static ScheduledExecutorService newScheduledThreadPool():创建固定大小的线程，可对任务做定时或延时执行。

public class TestThreadPool
{
	public static void main(String[] args) throws InterruptedException, ExecutionException
	{
		ThreadPoolDemo threadPoolDemo = new ThreadPoolDemo();
		//创建一个固定大小的线程池 大小为5
		ExecutorService pool = Executors.newFixedThreadPool(5);
		for (int i = 0; i < 10; i++)
		{
			pool.submit(threadPoolDemo); //为线程池中的线程分配任务
		}	
		pool.shutdown();//启动有序关闭。

	}
}

class ThreadPoolDemo implements Runnable
{
	@Override
	public void run()
	{
		int sum = 0;
		for (int i = 0; i <= 100; i++)
		{
			sum = sum + i;
		}
		System.out.println(Thread.currentThread().getName()+" : "+ sum);
	}
}

public class TestThreadPool
{
	public static void main(String[] args) throws InterruptedException, ExecutionException
	{
		//创建线程池 
		ExecutorService pool1 = Executors.newFixedThreadPool(5);
		//创建List对象用于存放线程结果
		List<Future<Integer>> list = new ArrayList<Future<Integer>>();
		
		for (int i = 0; i < 10; i++)
		{
		//提交线程任务
		Future<Integer> result = pool1.submit( new Callable<Integer>()
		{
			@Override
			public Integer call() throws Exception
			{
				int sum = 0;
				for (int i = 0; i <= 100; i++)
				{
					sum = sum + i;
				}
				return sum;
			}
		});
		list.add(result);
		}
		//关闭线程池
		pool1.shutdown();
		//遍历list
		for (Future<Integer> future : list)
		{
		System.out.println(future.get());
		}

	}
}

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class TestScheduledThreadPool
{
	public static void main(String[] args) throws InterruptedException, ExecutionException
	{
		//创建固定大小的线程，可以延迟或定时的执行任务。
		ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
		for(int i = 0; i < 10; i++) //创建10个线程任务
		{
			//创建并执行在给定延迟后启用的ScheduledFuture
			ScheduledFuture<Integer> result = pool.schedule(new Callable<Integer>()
			{
				@Override
				public Integer call() throws Exception
				{
					int num = new Random().nextInt(100);
					System.out.println(Thread.currentThread().getName()+" : "+ num);
					return num;
				}
			}, 2, TimeUnit.SECONDS);
			System.out.println(result.get());
		}
		//关闭线程池
		pool.shutdown();
	}
}