JAVA创建自己的线程池
文章分类:Java编程
package proxy;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
//测试main入口
public class CocurrentThread {
public static void main(String[] args){
//创建一个线程池,可以运行5条线程
PoolThread pt = new PoolThread(5);
//开启线程池工作开关
pt.start();
//往线程池中加入10个任务
for(int i = 0;i < 10;i++){
pt.execute(new ConcreteTask());
}
//关闭线程池开关
pt.shutdown();
}
}
/**
*要交给线程池处理的具体任务,用户可以自定义,不一定要实现Runnable接口,这里实现
*Runnable只是利用Runnable接口生成一种规范。
**/
class ConcreteTask implements Runnable{
private static int i;
//具体实现的任务在这里编写
public void run() {
System.out.println(Thread.currentThread().toString() + i++);
}
}
/**
*线程池核心类
**/
class PoolThread{
//实现线程池对象时最大的可用线程数
private int maxThreads;
//线程池工作的启动开关
private boolean on = false;
//这里定义了一个任务队列容器,用途很明显,就是用来放置要处理的任务,先进来的先交给线程池处理
private Queue<Runnable> tasks = new ConcurrentLinkedQueue<Runnable>();//任务队列
//定义了一个放置Thread对象的容器,用来放置所有的线程
private List<Thread> poolThreads ;
//构造器,初始化时根据传入的参数来分配几条线程处理任务
public PoolThread(int maxThreads){
this.maxThreads = maxThreads;
poolThreads = new ArrayList<Thread>();
for(int i = 0;i < this.maxThreads;i++){
poolThreads.add(new Thread(new SingleThread()));
}
}
/**
*启动线程池,其实就是启动里面的每一条线程
*/
public void start(){
this.on = true;
for(int i = 0 ;i < poolThreads.size();i++){
//启动每个线程
poolThreads.get(i).start();
System.out.println("the number " + i + " thread of " + poolThreads.size());
}
}
/**
*关闭线程池的工作
*/
public void shutdown(){
this.on = false;
}
/**
*
* @param task 被执行的新任务,实现Runnable接口
*/
public void execute(Runnable task){
synchronized(tasks){
tasks.add(task);//将任务添加到线程池中执行
tasks.notifyAll(); //通知所有的锁定tasks线程,让其执行新加进来的任务
}
}
/**
*定义线程池中的线程类,该线程必需是永远不终止的。
*/
class SingleThread implements Runnable{
public void run() {
while(on){
synchronized(tasks){
Runnable task = tasks.poll(); //取出任务队列中的任务执行
if(task != null)
task.run();
if(tasks.size() == 0){ //如果队列中没有等待的任务,则停止线程,直到有任务加进队列时唤醒该线程
try {
tasks.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}
文章分类:Java编程
package proxy;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
//测试main入口
public class CocurrentThread {
public static void main(String[] args){
//创建一个线程池,可以运行5条线程
PoolThread pt = new PoolThread(5);
//开启线程池工作开关
pt.start();
//往线程池中加入10个任务
for(int i = 0;i < 10;i++){
pt.execute(new ConcreteTask());
}
//关闭线程池开关
pt.shutdown();
}
}
/**
*要交给线程池处理的具体任务,用户可以自定义,不一定要实现Runnable接口,这里实现
*Runnable只是利用Runnable接口生成一种规范。
**/
class ConcreteTask implements Runnable{
private static int i;
//具体实现的任务在这里编写
public void run() {
System.out.println(Thread.currentThread().toString() + i++);
}
}
/**
*线程池核心类
**/
class PoolThread{
//实现线程池对象时最大的可用线程数
private int maxThreads;
//线程池工作的启动开关
private boolean on = false;
//这里定义了一个任务队列容器,用途很明显,就是用来放置要处理的任务,先进来的先交给线程池处理
private Queue<Runnable> tasks = new ConcurrentLinkedQueue<Runnable>();//任务队列
//定义了一个放置Thread对象的容器,用来放置所有的线程
private List<Thread> poolThreads ;
//构造器,初始化时根据传入的参数来分配几条线程处理任务
public PoolThread(int maxThreads){
this.maxThreads = maxThreads;
poolThreads = new ArrayList<Thread>();
for(int i = 0;i < this.maxThreads;i++){
poolThreads.add(new Thread(new SingleThread()));
}
}
/**
*启动线程池,其实就是启动里面的每一条线程
*/
public void start(){
this.on = true;
for(int i = 0 ;i < poolThreads.size();i++){
//启动每个线程
poolThreads.get(i).start();
System.out.println("the number " + i + " thread of " + poolThreads.size());
}
}
/**
*关闭线程池的工作
*/
public void shutdown(){
this.on = false;
}
/**
*
* @param task 被执行的新任务,实现Runnable接口
*/
public void execute(Runnable task){
synchronized(tasks){
tasks.add(task);//将任务添加到线程池中执行
tasks.notifyAll(); //通知所有的锁定tasks线程,让其执行新加进来的任务
}
}
/**
*定义线程池中的线程类,该线程必需是永远不终止的。
*/
class SingleThread implements Runnable{
public void run() {
while(on){
synchronized(tasks){
Runnable task = tasks.poll(); //取出任务队列中的任务执行
if(task != null)
task.run();
if(tasks.size() == 0){ //如果队列中没有等待的任务,则停止线程,直到有任务加进队列时唤醒该线程
try {
tasks.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}