可扩展的多线程通用Server框架

kayo

浏览: 550849 次
性别:
来自: 安徽

最近访客更多访客>>

ssk168

zzy7075

hxgg

yangbo126

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

JAVA体系

多线程框架 Socket C C++

可扩展的多线程通用Server框架

/*
* Copyright (c) 2000 David Flanagan. All rights reserved.
* This code is from the book Java Examples in a Nutshell, 2nd Edition.
* It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
* You may study, use, and modify it for any non-commercial purpose.
* You may distribute it non-commercially as long as you retain this notice.
* For a commercial use license, or to purchase the book (recommended),
* visit http://www.davidflanagan.com/javaexamples2.
*/

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

/**
* This class is a generic framework for a flexible, multi-threaded server. It
* listens on any number of specified ports, and, when it receives a connection
* on a port, passes input and output streams to a specified Service object
* which provides the actual service. It can limit the number of concurrent
* connections, and logs activity to a specified stream.
*/
public class Server {
   /**
    * A main() method for running the server as a standalone program. The
    * command-line arguments to the program should be pairs of servicenames and
    * port numbers. For each pair, the program will dynamically load the named
    * Service class, instantiate it, and tell the server to provide that
    * Service on the specified port. The special -control argument should be
    * followed by a password and port, and will start special server control
    * service running on the specified port, protected by the specified
    * password.
    */
   public static void main ( String [] args ) {
     try {
       if ( args.length < 2 ) // Check number of arguments
         throw new IllegalArgumentException ( "Must specify a service" ) ;

       // Create a Server object that uses standard out as its log and
       // has a limit of ten concurrent connections at once.
       Server s = new Server ( System.out, 10 ) ;

       // Parse the argument list
       int i = 0 ;
       while ( i < args.length ) {
         if ( args [ i ] .equals ( "-control" )) { // Handle the -control arg
           i++;
           String password = args [ i++ ] ;
           int port = Integer.parseInt ( args [ i++ ]) ;
           // add control service
           s.addService ( new Control ( s, password ) , port ) ;
         } else {
           // Otherwise start a named service on the specified port.
           // Dynamically load and instantiate a Service class
           String serviceName = args [ i++ ] ;
           Class serviceClass = Class .forName ( serviceName ) ;
           Service service = ( Service ) serviceClass.newInstance () ;
           int port = Integer.parseInt ( args [ i++ ]) ;
           s.addService ( service, port ) ;
         }
       }
     } catch ( Exception e ) { // Display a message if anything goes wrong
       System.err.println ( "Server: " + e ) ;
       System.err.println ( "Usage: java Server "
           + "[-control <password> <port>] "
           + "[<servicename> <port> ... ]" ) ;
       System.exit ( 1 ) ;
     }
   }

   // This is the state for the server
   Map services; // Hashtable mapping ports to Listeners

   Set connections; // The set of current connections

   int maxConnections; // The concurrent connection limit

   ThreadGroup threadGroup; // The threadgroup for all our threads

   PrintWriter logStream; // Where we send our logging output to

   /**
    * This is the Server() constructor. It must be passed a stream to send log
    * output to (may be null), and the limit on the number of concurrent
    * connections.
    */
   public Server ( OutputStream logStream, int maxConnections ) {
     setLogStream ( logStream ) ;
     log ( "Starting server" ) ;
     threadGroup = new ThreadGroup ( Server. class .getName ()) ;
     this .maxConnections = maxConnections;
     services = new HashMap () ;
     connections = new HashSet ( maxConnections ) ;
   }

   /**
    * A public method to set the current logging stream. Pass null to turn
    * logging off
    */
   public synchronized void setLogStream ( OutputStream out ) {
     if ( out != null )
       logStream = new PrintWriter ( out ) ;
     else
       logStream = null ;
   }

   /** Write the specified string to the log */
   protected synchronized void log ( String s ) {
     if ( logStream != null ) {
       logStream.println ( "[" + new Date () + "] " + s ) ;
       logStream.flush () ;
     }
   }

   /** Write the specified object to the log */
   protected void log ( Object o ) {
     log ( o.toString ()) ;
   }

   /**
    * This method makes the server start providing a new service. It runs the
    * specified Service object on the specified port.
    */
   public synchronized void addService ( Service service, int port )
       throws IOException {
     Integer key = new Integer ( port ) ; // the hashtable key
     // Check whether a service is already on that port
     if ( services.get ( key ) != null )
       throw new IllegalArgumentException ( "Port " + port
           + " already in use." ) ;
     // Create a Listener object to listen for connections on the port
     Listener listener = new Listener ( threadGroup, port, service ) ;
     // Store it in the hashtable
     services.put ( key, listener ) ;
     // Log it
     log ( "Starting service " + service.getClass () .getName () + " on port "
         + port ) ;
     // Start the listener running.
     listener.start () ;
   }

   /**
    * This method makes the server stop providing a service on a port. It does
    * not terminate any pending connections to that service, merely causes the
    * server to stop accepting new connections
    */
   public synchronized void removeService ( int port ) {
     Integer key = new Integer ( port ) ; // hashtable key
     // Look up the Listener object for the port in the hashtable
     final Listener listener = ( Listener ) services.get ( key ) ;
     if ( listener == null )
       return ;
     // Ask the listener to stop
     listener.pleaseStop () ;
     // Remove it from the hashtable
     services.remove ( key ) ;
     // And log it.
     log ( "Stopping service " + listener.service.getClass () .getName ()
         + " on port " + port ) ;
   }

   /**
    * This nested Thread subclass is a "listener". It listens for connections
    * on a specified port (using a ServerSocket) and when it gets a connection
    * request, it calls the servers addConnection() method to accept (or
    * reject) the connection. There is one Listener for each Service being
    * provided by the Server.
    */
   public class Listener extends Thread {
     ServerSocket listen_socket; // The socket to listen for connections

     int port; // The port we're listening on

     Service service; // The service to provide on that port

     volatile boolean stop = false ; // Whether we've been asked to stop

     /**
      * The Listener constructor creates a thread for itself in the
      * threadgroup. It creates a ServerSocket to listen for connections on
      * the specified port. It arranges for the ServerSocket to be
      * interruptible, so that services can be removed from the server.
      */
     public Listener ( ThreadGroup group, int port, Service service )
         throws IOException {
       super ( group, "Listener:" + port ) ;
       listen_socket = new ServerSocket ( port ) ;
       // give it a non-zero timeout so accept() can be interrupted
       listen_socket.setSoTimeout ( 600000 ) ;
       this .port = port;
       this .service = service;
     }

     /***********************************************************************
      * This is the polite way to get a Listener to stop accepting
      * connections
      **********************************************************************/
     public void pleaseStop () {
       this .stop = true ; // Set the stop flag
       this .interrupt () ; // Stop blocking in accept()
       try {
         listen_socket.close () ;
       } // Stop listening.
       catch ( IOException e ) {
       }
     }

     /**
      * A Listener is a Thread, and this is its body. Wait for connection
      * requests, accept them, and pass the socket on to the addConnection
      * method of the server.
      */
     public void run () {
       while ( !stop ) { // loop until we're asked to stop.
         try {
           Socket client = listen_socket.accept () ;
           addConnection ( client, service ) ;
         } catch ( InterruptedIOException e ) {
         } catch ( IOException e ) {
           log ( e ) ;
         }
       }
     }
   }

   /**
    * This is the method that Listener objects call when they accept a
    * connection from a client. It either creates a Connection object for the
    * connection and adds it to the list of current connections, or, if the
    * limit on connections has been reached, it closes the connection.
    */
   protected synchronized void addConnection ( Socket s, Service service ) {
     // If the connection limit has been reached
     if ( connections.size () >= maxConnections ) {
       try {
         // Then tell the client it is being rejected.
         PrintWriter out = new PrintWriter ( s.getOutputStream ()) ;
         out.print ( "Connection refused; "
             + "the server is busy; please try again later.\n" ) ;
         out.flush () ;
         // And close the connection to the rejected client.
         s.close () ;
         // And log it, of course
         log ( "Connection refused to "
             + s.getInetAddress () .getHostAddress () + ":"
             + s.getPort () + ": max connections reached." ) ;
       } catch ( IOException e ) {
         log ( e ) ;
       }
     } else { // Otherwise, if the limit has not been reached
       // Create a Connection thread to handle this connection
       Connection c = new Connection ( s, service ) ;
       // Add it to the list of current connections
       connections.add ( c ) ;
       // Log this new connection
       log ( "Connected to " + s.getInetAddress () .getHostAddress () + ":"
           + s.getPort () + " on port " + s.getLocalPort ()
           + " for service " + service.getClass () .getName ()) ;
       // And start the Connection thread to provide the service
       c.start () ;
     }
   }

   /**
    * A Connection thread calls this method just before it exits. It removes
    * the specified Connection from the set of connections.
    */
   protected synchronized void endConnection ( Connection c ) {
     connections.remove ( c ) ;
     log ( "Connection to " + c.client.getInetAddress () .getHostAddress () + ":"
         + c.client.getPort () + " closed." ) ;
   }

   /** Change the current connection limit */
   public synchronized void setMaxConnections ( int max ) {
     maxConnections = max;
   }

   /**
    * This method displays status information about the server on the specified
    * stream. It can be used for debugging, and is used by the Control service
    * later in this example.
    */
   public synchronized void displayStatus ( PrintWriter out ) {
     // Display a list of all Services that are being provided
     Iterator keys = services.keySet () .iterator () ;
     while ( keys.hasNext ()) {
       Integer port = ( Integer ) keys.next () ;
       Listener listener = ( Listener ) services.get ( port ) ;
       out.print ( "SERVICE " + listener.service.getClass () .getName ()
           + " ON PORT " + port + "\n" ) ;
     }

     // Display the current connection limit
     out.print ( "MAX CONNECTIONS: " + maxConnections + "\n" ) ;

     // Display a list of all current connections
     Iterator conns = connections.iterator () ;
     while ( conns.hasNext ()) {
       Connection c = ( Connection ) conns.next () ;
       out.print ( "CONNECTED TO "
           + c.client.getInetAddress () .getHostAddress () + ":"
           + c.client.getPort () + " ON PORT "
           + c.client.getLocalPort () + " FOR SERVICE "
           + c.service.getClass () .getName () + "\n" ) ;
     }
   }

   /**
    * This class is a subclass of Thread that handles an individual connection
    * between a client and a Service provided by this server. Because each such
    * connection has a thread of its own, each Service can have multiple
    * connections pending at once. Despite all the other threads in use, this
    * is the key feature that makes this a multi-threaded server
    * implementation.
    */
   public class Connection extends Thread {
     Socket client; // The socket to talk to the client through

     Service service; // The service being provided to that client

     /**
      * This constructor just saves some state and calls the superclass
      * constructor to create a thread to handle the connection. Connection
      * objects are created by Listener threads. These threads are part of
      * the server's ThreadGroup, so all Connection threads are part of that
      * group, too.
      */ <br

分享到：

扫描端口是否占用 | 对client生成的线程池进行管理

2009-03-31 13:38
浏览 1313
评论(0)
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论