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();
}
}


a46d