线程池

线程池

　　是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源

　　目的：节省资源

    通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。

使用线程池方式--Runnable接口

使用线程池中线程对象的步骤：

n  创建线程池对象

n  创建Runnable接口子类对象

n  提交Runnable接口子类对象

n  关闭线程池

package com.oracle.Demo02;

public class MyRunnable2 implements Runnable{
		public void run() {
			for (int i = 0; i <100; i++) {
				//getName（） 得到线程名称
				System.out.println(Thread.currentThread().getName()+":"+i);
			}
		}
	
}

package com.oracle.Demo02;

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

public class Demo01 {

	public static void main(String[] args) {
		//从线程池工厂中创建线程池对象
		ExecutorService es=Executors.newFixedThreadPool(2);
		//创建线程任务对象
		MyRunnable2 mr=new MyRunnable2();
		//提交线程任务，让线程随机挑选一条想吃执行线程任务
		es.submit(mr);
		es.submit(mr);
		es.submit(mr);
		//释放资源
		es.shutdown();

	}

}

　　

使用线程池方式—Callable接口

l  Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。

l  ExecutorService：线程池类

n  <T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法

l  Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

 

l  使用线程池中线程对象的步骤：

n  创建线程池对象

n  创建Callable接口子类对象

n  提交Callable接口子类对象

n  关闭线程池

package com.oracle.Demo02;

import java.util.concurrent.Callable;

public class MyCallble implements Callable<String> {

	@Override
	public String call() throws Exception {
		// TODO Auto-generated method stub
		return "abc";
	}

}

package com.oracle.Demo02;

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

public class Demo02 {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//从线程池工厂中创建线程池对象
		ExecutorService ex=Executors.newFixedThreadPool(2);
		//创建线程任务对象
		MyCallble mc=new MyCallble();
		//执行线程任务并获取call方法返回值
		Future<String> f=ex.submit(mc);
		//从Future中获取返回值
		String str=f.get();
		System.out.println(str);
		//释放资源
		ex.shutdown();
		

	}

}

　　2个线程，1个线程计算1-100的和，另一个线程计算1-200的和

package com.oracle.Demo02;

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

public class Demo04 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//2个线程，1个线程计算1-100的和，另一个线程计算1-200的和
		//创建俩个线程任务
		GetSum sum1=new GetSum(1,100);
		GetSum sum2=new GetSum(1,200);
		//从线程池中创建线程池对象
		ExecutorService ex=Executors.newFixedThreadPool(2);
		//执行线程任务并获取call方法返回值
		Future<Integer> f1=ex.submit(sum1);
		Future<Integer> f2=ex.submit(sum2);
		//获取返回值
		System.out.println(f1.get());
		System.out.println(f2.get());
		//关闭线程
		ex.shutdown();
	}
}

package com.oracle.Demo02;

import java.util.concurrent.Callable;

public class GetSum implements Callable<Integer>{
	private int a;
	private int b;
	
	public int getA() {
		return a;
	}

	public void setA(int a) {
		this.a = a;
	}

	public int getB() {
		return b;
	}

	public void setB(int b) {
		this.b = b;
	}

	public GetSum() {
		super();
	}

	public GetSum(int a, int b) {
		super();
		this.a = a;
		this.b = b;
	}

	@Override
	public Integer call() throws Exception {
		// TODO Auto-generated method stub
		int sum=0;
		for (int i = a; i < b; i++) {
			sum=sum+i;
		}
		return sum;
	}
	
}