一、線程池:如果每次都產生一個新的線程用浪費系統的很多資源，這時用線程池，
 	   不用讓其處于等待狀態，用時將其激活。
 	   有三個角色分別是線程池、任務、線程，線程池同時管理任務及線程，
 	   客戶通過線程池向任務列表加入新的任務，當有新的任務時激活一個線程，
 	   讓其完成任務。
     public interface Task
     {
     	public void task();
     }
     public class MyTask implements Task
     {
     	private int i;
     	public MyTask(int i)
     	{
     		this.i=i;
     	}
     	public void task()
     	{
     		System.out.println("任務"+i+"號開始了");
     		Thread.sleep(1000);
     		System.out.println("任務"+i+"號結束了");
     	}
     }
     public class MyThread extends Thread
     {
     	ThreadPool tp;
     	public MyThread(String threadName,ThreadPool tp)
     	{
     		super(threadName);
     		this.tp=tp;
     	}
     	public void run()
     	{
     	  while(!this.isInterupt)
     	  {
     	  	task=tp.remove();
     	  	if(task!=null)
     	  	{
     	  		task.task();
     	  	}
     	  }
     	}
     }
     public class ThreadPool extends ThreadGroup
     {
     	private boolean isRunning;
     	private LinkedList tasks=new LinkedList();
     	private Thread[] threads=new MyThread[5];
     	public ThreadPool()
     	{
     		for(int i=0;i<threads.length;i++)
     		{
     			threads[i]=new MyThread();
     			threads[i].start();
     		}
     	}
     	public synchronized void add(Task task)
     	{
     		//如果線程組沒有運行，讓調用的線程等待
     		if(!this.isRunning)
     		{
     			wait();
     		}
     		tasks.add(task);
     		notify();
     	}
     	public synchronized Task remove()
     	{
     		Task task=null;
     		//如果沒有任務，讓線程等待
     		if(this.task.size()==0||!this.isRunning)
     		{
     			wait();
     		}
     		if(this.isRunning)
     		{
     			task=tasks.removeLast();
     		}
     		notify();
     		return;
     	}
     	public void stopPool()
     	{
     		synchnoized(this)
     		{
     			this.isRunning=false;
     			//將所有線程中斷
     			this.interrupt();
     		}
     	}
     }
二、顯示當前進程下的所有線程
	1、找到根線程組
	2、遍歷每一個線程組下的線程
		1、得到活動線程的方法
			activeCount();//活動線程數
			int enumerate(Thread[] threads)//將活動線程引用復制到線程數組中
			Thread(ThreadGroup tg,String name);//產生一個新的線程，說明其所屬線程組
		2、線程組的方法
			activeGroupCount();//線程組的個數
			getParent();//得到父線組
			ThreadGroup(ThreadGroup tg,String name);//從屬某一個線程組的線程
	3、實現
		a、取出根線程組
			public class GetAll
			{
				public ThreadGroup getRoot()
				{
					ThreadGroup tg1=Thread.currentThread.getThreadGroup();
					ThreadGroup pre=tg1;
					while(tg1!=null)
					{
						pre=tg1;
						//得到父線程組
						tg1=tg1.getParent();
					}
				}
				//取出所有的線程
				public void getAll(String space,ThreadGroup tg)
				{
					//對線程的操作
					int threadCount=tg.actionCount();
					Thread threads[]=new Thread(threadCount);
					int realCount=tg.enumerate(threads,false);
					for(int i=0;i<realCount;i++)
					{
						System.out.println(space+threads[i].getName());
					}
					//對線程組的操作
					int threadGroupCount=tg.actionGroupCount();
					ThreadGroup tgs=new ThreadGroup(threadGroupCount);
					int threadGroupRealCount=tg.enumerate(tgs,false);
					for(int i=0;i<threadGroupRealCount;i++)
					{
						getAll(space+"\t",tgs[i]);
					}
				}
			}
		b、寫一個線程
			public class MyThread extends Thead
			{
				publicl MyThread(ThreadGroup tg,String threadName)
				{
					super(tg,threadName);
				}
				public void run()
				{
					Thread.sleep(1000);
				}
			}
		c、客戶端
			public static void main(String[] args)
			{
				ThreadGroup tg1=new ThreadGroup("線程組1");
				for(int i=0;i<10;i++)
				{
					new MyThread(tg1,"name1-"+i).start();
				}
				ThreadGroup tg2=new ThreadGroup(tg1,"線程組2");
				for(int i=0;i<10;i++)
				{
					new MyThread(tg2,"name2-"+i).start();
				}
				GetAll getAll=new GetAll();
				getAll.getAll();
				
			}
一、多線程的服務框架
	兩個線程一個普通類。
	兩個線程:
		1、監聽線程
		public class Listener extends Thread
		{
			private int i=0;
			private ServerSocket serverSocket=new ServerSocket(4001);
			private boolean isRunning=true;
			public void run()
			{
				while(isRunning)
				{
					Socket socket=serverSocket.accept();
					new Connection(I+"name",socket).start();
				}
			}
		}
		2、會話線程
		public class Connection extends Thread
		{
			private Socket socket;
			private Service service;
			public Connection(String threadName,Socket socket)
			{
				super(threadName);
				service=new ReverseService();
				this.socket=socket;
				
			}
			public void run()
			{
				this.service.service(socket.getInputStream(),socket.getOutputStream());
			}
		}
	一個普通類:提供具體的服務
		public interface service
		{
			public void serivce(InputStream is,OutputStream os);
		}
		public class ReverseService implements Service
		{
			public void service(InputStream is,OuputStream os)
			{
				BufferedReader br=new BufferedReader(new InputSteamReader(is));
				PrintStream ps=new PrintStream(os);
				ps.println("請輸入信息>>>>>:");
				String temp=br.readeLine();
				while(!"stop".equals(temp))
				{
					String temp1="";
					for(int i=0;i<temp.length();i++)
					{
						temp1=temp.charAt(i)+temp1;
					}
					ps.println(temp1);
					temp=br.readLine();
				}
				ps.close;
				br.close;
			}
		}
七、線程的生命周期
	就緒:實例化一個線程
		Thread th1=new MyThread(0);
	啟動:通過start方法啟動線程與主線程并發運行
		th1.start();
	運行:調用run方法
	休眠:sleep
	等待:
		wait
	激活:
		notify
	掛起:suspend
	恢復:resume
	銷毀:
		stop:有垃圾的清理工作
		destroy:沒有垃圾清理工作
	yield:將當前線程放到要執行線程隊最后，最后執行。
二、wait、notify、notifyAll();
    這個關鍵必須在同步塊或同步方法是執行，沒有在同步中報錯。
    wait:讓當前線程處于等待狀態，并釋放其占用的資源。
    notify:激活等待隊列中的一個線程
    notifyAll():激活等待隊列中所有的線程
    當執行wait時，當前線程調用的代碼暫停，通過notify激活線程
    時，當前線程執行暫停后下一行代碼。        
    有三個角色分別是倉庫、生產者、消費者，有很多生產者它們都是線程，
    每1秒鐘生成一個產品，當倉庫滿時讓生產者等待，有很多消費者它們也
    都是線程，每2秒鐘消費一個產品，當倉庫沒有產品時讓消費者等待。生
    產者者生產完成一個產品后通過notify激活一個線程可能是消費者，也可能
    生產者，消費者消費完一個產品后通過notify激活一個線程可能是消費者，也
    可能是生產者。
    public class Product
    {
    	private int productID;
    	private String productName;