thread.txt

Java大部分的基础知识,EJB3,EJB2,WEBSERVICE,SOAP,JMS,MQ,还有些面试题

一、线程池:如果每次都产生一个新的线程用浪费系统的很多资源，这时用线程池，
 	   不用让其处于等待状态，用时将其激活。
 	   有三个角色分别是线程池、任务、线程，线程池同时管理任务及线程，
 	   客户通过线程池向任务列表加入新的任务，当有新的任务时激活一个线程，
 	   让其完成任务。
     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;