logserver.java

p2p仿真

package gps.util;

import java.util.HashSet;
import java.util.Iterator;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.logging.LogRecord;


/**
 * log server handles concurrent log request, and runs in a seperate thread 
 * 
 * 
 * @author  Weishuai Yang
 * @version 1.2,  6/20/2005
 */
public class LogServer extends Thread {
	/**
	 * log server running status
	 */
	private static boolean mRunning=true;
	/**
	 * singleton instance
	 */
	private static LogServer mInstance=null;
	
	/**
	 * log record queue
	 */
	private static ConcurrentLinkedQueue mQueue=new ConcurrentLinkedQueue();
	/**
	 * handlers that record log to the log server
	 */
	private static HashSet mHandlerSet=new HashSet(3);
	/**
	 * get singleton instance
	 * @return LogServer instance
	 */
	public static LogServer getInstance(){
		if(mInstance==null){
			mInstance=new LogServer();
			mInstance.start();
		}
		if(!mRunning){
			mQueue.clear();
			mHandlerSet.clear();
			mInstance.start();
		}
		return mInstance;
	}

	/**
	 * dummy constructor
	 */
	public LogServer() {}
	
	/**
	 * asynchornous file handler call this function to write log record to the log server.
	 * @param h asynchornous file handler
	 * @param r record to be logged
	 */
	public synchronized void log(AsyncFileHandler h, LogRecord r){
			mQueue.offer(new HandlerRecordPair(h, r));
			mHandlerSet.add(h);
	}

	/**
	 * run a seperate thread to write each log record into the 
	 * related file in order of the arrival time.
	 */

    public void run() {
	   mRunning=true;
       while(true){
       	    HandlerRecordPair p=(HandlerRecordPair)mQueue.poll();
       		if(p!=null) 
       			p.mHandler.syncPublish(p.mRecord);
       	    
       	    if(mQueue.isEmpty()){
       			Iterator it=mHandlerSet.iterator();
		        while(it.hasNext()){
		        	AsyncFileHandler h= (AsyncFileHandler)it.next();
		        	if(h.isClosed()){
		        		h.syncClose();
		        		it.remove();
		        	}
		        }
		        if(!mRunning) break;
				try {
	       			Thread.sleep(100);
	       		} catch (InterruptedException ex) { System.out.println("Log Server Sleep Interrupted!");}
       		}
       }
       
       Iterator it=mHandlerSet.iterator();
       while(it.hasNext())
       		((AsyncFileHandler)it.next()).syncClose();
    }
	/**
	 * hanlt log server
	 */
	public void halt()
  	{
	    mRunning = false;
  	}
	/**
	 * a pare of handler and record. inner class
	 */
	public class HandlerRecordPair
	{
		/**
		 * handler
		 */
		public AsyncFileHandler mHandler=null;
		/**
		 * record
		 */
		public LogRecord mRecord=null;
		/**
		 * constructor
		 * @param h handler
		 * @param l record
		 */
		HandlerRecordPair(AsyncFileHandler h, LogRecord l){
			mHandler=h;
			mRecord=l;
		}
	}	
	/**
	 * test function		 
	 */
	 /*
	public static void main(String[] args) throws IOException{
		LogServer ls=LogServer.getInstance();
		Logger log1 = Logger.getLogger("1osg1");
		Logger log2 = Logger.getLogger("1osg2");
		
		AsyncFileHandler mHandler1 = new AsyncFileHandler("log1");
		log1.addHandler(mHandler1);

		AsyncFileHandler mHandler2 = new AsyncFileHandler("log2");
		log2.addHandler(mHandler2);
		
		log1.warning("abcd from log1");
		log2.warning("asdfasdf from log2");
		log1.warning("absdfsdfdfcd from log1");
		log2.warning("asdfsdfsdfdsfasdf from log2");
		ls.halt();
		
	}
	*/
}