Java学习之线程池

1、使用线程池的目的：

程序启动一个新线程成本是比较高的，因为它要设计到要与操作系统进行交互，而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程是，更应该考虑使用线程池

2、特点：

线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用

3、创建

在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池

JDK5新增了一个Executors工厂类来生产线程池，

public static ExecutorService newFixedThreadPool(int nTheads)

使用步骤：

（1）创建线程池对象

ExecutorService pool = Executors.newFixedThreadPool(2);

（2）创建Runnable实例

MyRunnable my = new MyRunnable();

（3）提交Runnable实例

pool.submit(my);

（4）关闭线程池

pool.shutdown();

案例1：实现Runnable接口实现线程池的使用

代码：

package com.edu_07;

public class MyRunnable implements Runnable{

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(i);
		}
	}

}

主程序：

package com.edu_07;

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

public class ExecutorsDemo {
	public static void main(String[] args) {
		//创建线程池对象 ExecutorService pool = Executors.newFixedThreadPool(2);
		ExecutorService es = Executors.newFixedThreadPool(2);
		
		//创建MyRunnable实例
		MyRunnable mr = new MyRunnable();
		MyRunnable mr2 = new MyRunnable();
		
		//提交实例
		es.submit(mr);
		es.submit(mr2);
		
		//关闭线程池
		es.shutdown();
	}
}

案例2：实现Callable接口实现线程池的使用

package com.edu_08;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Object>{

	@Override
	public Object call() throws Exception {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
		return null;
	}


}

主程序：

package com.edu_08;

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

public class Test {
	public static void main(String[] args) {
		
		//创建线程池对象 ExecutorService pool = Executors.newFixedThreadPool(2);
		ExecutorService es = Executors.newFixedThreadPool(2);
		
		//创建MyRunnable实例
		MyCallable mr = new MyCallable();
		MyCallable mr2 = new MyCallable();
		
		//提交实例
		es.submit(mr);
		es.submit(mr2);
		
		//关闭线程池
		es.shutdown();
	}
}

案例3：实现Callable接口实现线程池的使用，实现多线程求和，1-10之和，1-100之和

package com.edu_09;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer>{
	private int start;
	private int end;
	public MyCallable(int start,int end){
		this.start = start;
		this.end = end;
	}
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int i = start; i < end+1; i++) {
			sum +=i;
		}
		return sum;
	}


}

主程序：

package com.edu_09;

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

public class Test {
	public static void main(String[] args) throws Exception {
		
		//创建线程池对象 ExecutorService pool = Executors.newFixedThreadPool(2);
		ExecutorService es = Executors.newFixedThreadPool(2);
		
		//创建MyRunnable实例
		MyCallable mr = new MyCallable(1,10);
		MyCallable mr2 = new MyCallable(1,100);
		
		//提交实例
		Future<Integer> sm1 = es.submit(mr);
		Future<Integer> sm2 = es.submit(mr2);
		
		//获取返回值
		System.out.println(sm1.get());
		System.out.println(sm2.get());
		
		//关闭线程池
		es.shutdown();
	}
}