// This example is from the book _Java in a Nutshell_ by David Flanagan.
// Written by David Flanagan. Copyright (c) 1996 O'Reilly & Associates.
// You may study, use, modify, and distribute this example for any purpose.
// This example is provided WITHOUT WARRANTY either expressed or implied.
import java.net.*;
import java.io.*;
import java.awt.*;
import java.util.*;
public class Server extends Thread {
public final static int DEFAULT_PORT = 6789;
protected int port;
protected ServerSocket listen_socket;
protected ThreadGroup threadgroup;
protected List connection_list;
protected Vector connections;
protected Vulture vulture;
// Exit with an error message, when an exception occurs.
public static void fail(Exception e, String msg) {
System.err.println(msg + ": " + e);
System.exit(1);
}
// Create a ServerSocket to listen for connections on; start the thread.
public Server(int port) {
// Create our server thread with a name.
super("Server");
if (port == 0) port = DEFAULT_PORT;
this.port = port;
try { listen_socket = new ServerSocket(port); }
catch (IOException e) { fail(e, "Exception creating server socket"); }
// Create a threadgroup for our connections
threadgroup = new ThreadGroup("Server Connections");
// Create a window to display our connections in
Frame f = new Frame("Server Status");
connection_list = new List();
f.add("Center", connection_list);
f.resize(400, 200);
f.show();
// Initialize a vector to store our connections in
connections = new Vector();
// Create a Vulture thread to wait for other threads to die.
// It starts itself automatically.
vulture = new Vulture(this);
// Start the server listening for connections
this.start();
}
// The body of the server thread. Loop forever, listening for and
// accepting connections from clients. For each connection,
// create a Connection object to handle communication through the
// new Socket. When we create a new connection, add it to the
// Vector of connections, and display it in the List. Note that we
// use synchronized to lock the Vector of connections. The Vulture
// class does the same, so the vulture won't be removing dead
// connections while we're adding fresh ones.
public void run() {
try {
while(true) {
Socket client_socket = listen_socket.accept();
Connection c = new Connection(client_socket, threadgroup,
3, vulture);
// prevent simultaneous access.
synchronized (connections) {
connections.addElement(c);
connection_list.addItem(c.toString());
}
}
}
catch (IOException e) {
fail(e, "Exception while listening for connections");
}
}
// Start the server up, listening on an optionally specified port
public static void main(String[] args) {
int port = 0;
if (args.length == 1) {
try { port = Integer.parseInt(args[0]); }
catch (NumberFormatException e) { port = 0; }
}
new Server(port);
}
}
// This class is the thread that handles all communication with a client
// It also notifies the Vulture when the connection is dropped.
class Connection extends Thread {
static int connection_number = 0;
protected Socket client;
protected Vulture vulture;
protected DataInputStream in;
protected PrintStream out;
// Initialize the streams and start the thread
public Connection(Socket client_socket, ThreadGroup threadgroup,
int priority, Vulture vulture)
{
// Give the thread a group, a name, and a priority.
super(threadgroup, "Connection-" + connection_number++);
this.setPriority(priority);
// Save our other arguments away
client = client_socket;
this.vulture = vulture;
// Create the streams
try {
in = new DataInputStream(client.getInputStream());
out = new PrintStream(client.getOutputStream());
}
catch (IOException e) {
try { client.close(); } catch (IOException e2) { ; }
System.err.println("Exception while getting socket streams: " + e);
return;
}
// And start the thread up
this.start();
}
// Provide the service.
// Read a line, reverse it, send it back.
public void run() {
String line;
StringBuffer revline;
int len;
// Send a welcome message to the client
out.println("Line Reversal Server version 1.0");
out.println("A service of O'Reilly & Associates");
try {
for(;;) {
// read in a line
line = in.readLine();
if (line == null) break;
// reverse it
len = line.length();
revline = new StringBuffer(len);
for(int i = len-1; i >= 0; i--)
revline.insert(len-1-i, line.charAt(i));
// and write out the reversed line
out.println(revline);
}
}
catch (IOException e) { ; }
// When we're done, for whatever reason, be sure to close
// the socket, and to notify the Vulture object. Note that
// we have to use synchronized first to lock the vulture
// object before we can call notify() for it.
finally {
try { client.close(); } catch (IOException e2) { ; }
synchronized (vulture) { vulture.notify(); }
}
}
// This method returns the string representation of the Connection.
// This is the string that will appear in the GUI List.
public String toString() {
return this.getName() + " connected to: "
+ client.getInetAddress().getHostName()
+ ":" + client.getPort();
}
}
// This class waits to be notified that a thread is dying (exiting)
// and then cleans up the list of threads and the graphical list.
class Vulture extends Thread {
protected Server server;
protected Vulture(Server s) {
super(s.threadgroup, "Connection Vulture");
server = s;
this.start();
}
// This is the method that waits for notification of exiting threads
// and cleans up the lists. It is a synchronized method, so it
// acquires a lock on the `this' object before running. This is
// necessary so that it can call wait() on this. Even if the
// the Connection objects never call notify(), this method wakes up
// every five seconds and checks all the connections, just in case.
// Note also that all access to the Vector of connections and to
// the GUI List component are within a synchronized block as well.
// This prevents the Server class from adding a new conenction while
// we're removing an old one.
public synchronized void run() {
for(;;) {
try { this.wait(5000); } catch (InterruptedException e) { ; }
// prevent simultaneous access
synchronized(server.connections) {
// loop through the connections
for(int i = 0; i < server.connections.size(); i++) {
Connection c;
c = (Connection)server.connections.elementAt(i);
// if the connection thread isn't alive anymore,
// remove it from the Vector and List.
if (!c.isAlive()) {
server.connections.removeElementAt(i);
server.connection_list.delItem(i);
i--;
}
}
}
}
}
}
|
