线程池

线程池:

?一、线程池:

?用我的话来说，现在有很多线程任务要执行，比如很多人同时访问ITeye，这是，总不能来一个用户，就new一个线程去来接待用户吧，线程池就是预先创建了很多线程(用来处理任务线程的)，当有任务需要执行时，就取出线程对象执行任务，执行完毕后，并不销毁（等待JVM回收）线程对象，而是将其放入一个集合中，等待下一次任务的执行

?

?二、简单实现:

?1.任务线程

package 线程池;
/**
 * 运行的线程任务
 * @author Administrator
 *
 */
public class RunThreadTask implements Runnable {
	
	String name;
	public void SetName(String name){
		
       this.name =name;
	}
	
	public String getName(){
		
		return name;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		String name1 = Thread.currentThread().getName();
		try{
			
			while(true){
				
	System.out.println("当前运行的任务线程是:"+name+"<>"+"线程:"+name1);
	Thread.sleep(3000);
			}
		}catch(Exception ef){
			System.out.println("异常中断");	
		}
		
		System.out.println("执行完毕");
	}

}

?

?2.线程池:

package 线程池;

import java.util.LinkedList;

/**
 * 用线程池去管理 正在运行的线程任务
 * @author Administrator
 *
 */
public class MyThreadPool {

	
	private int theCountOfThreadPool;//线程池的大小
	private LinkedList  theListOfRunThreadTask;//保存运行的线程任务的List
	private theThreadOfThreadPool[] theListOfThreadPool;//用来处理线程任务的List
	
	
	
	public void execute(RunThreadTask runTask){
		
		synchronized (theListOfRunThreadTask) {
			
			theListOfRunThreadTask.addLast(runTask);
			
			theListOfRunThreadTask.notify();
			
			System.out.println("加入了一个任务"+runTask.getName());
		}
	}
	
	
	public static void main(String[] args) {
		
		MyThreadPool cb123456 = new MyThreadPool(10);
		
		RunThreadTask[] task = new RunThreadTask[20];
		//theListOfRunThreadTask =  LinkedList<RunThreadTask>;
		for (int i = 0; i < 20; i++) {
			task[i]= new RunThreadTask();
			task[i].SetName("任务EE"+i);
			//task[i].getName();
			//System.out.println("xxxx"+i);
			
			//task[i].run();
			cb123456.execute(task[i]);
		}
		
		
	}
	
	public MyThreadPool(int count){
		
		this.theCountOfThreadPool = count;
		
		theListOfRunThreadTask = new LinkedList();
		
		//定义线程池的大小
		theListOfThreadPool = new theThreadOfThreadPool[theCountOfThreadPool];
		
		for (int i = 0; i < theListOfThreadPool.length; i++) {
			//初始化每一个线程
			theListOfThreadPool[i] = new theThreadOfThreadPool();
			
			theListOfThreadPool[i].setName(i+"号线程WWW");
			
			theListOfThreadPool[i].start();
			
			System.out.println(i+"号线程已经创建，等待任务");
			
		}
		
		System.out.println("线程池初初始化完毕");
	}
	
	public class theThreadOfThreadPool extends Thread{
		
		@Override
		public void run() {
			// TODO Auto-generated method stub
			//super.run();
			RunThreadTask r;
			
			while(true){ 
				synchronized (theListOfRunThreadTask) {
					
					while(theListOfRunThreadTask.isEmpty()){
						
						try{
							theListOfRunThreadTask.wait();
							
						}catch(InterruptedException ef){
							
							
						}
						
					}
					
					
					
					//收到通知时，执行线程
					r= (RunThreadTask) theListOfRunThreadTask.removeLast();

				//此时r就是正在运行的线程任务;
					
				}
			
				//接着在让r对象run一下.
				r.run();
			
				
			}
		}

	}
}

?

?三、运行结果:

?

?

?四、执行流程:

? 通过构造函数，我们在线程池内创建了接待任务的线程，并让接待任务线程run起来，然后通过RunThreadTask[]，创建任务线程对象，每次创建一个就让线程池去处理，再让任务线程run起来.大概就是这么个流程

?

?五、结果分析:

?按照湖南的话来说，就是每次显示都是一大坨，呵，就是每一毫秒，都会同时执行很多任务的.内存也不会飚到很高的。

?

?六、补充:

Thread.currentThread()：

?

?七、总结:

使用线程池，不是很占我的内存，运行速度快，一次可以处理多个任务.