ping.java

java应用开发详解

import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.util.*;


public class Ping 
{
    static int port = 80;
    
    static class Target {

	InetSocketAddress address;
	SocketChannel channel;
	Exception failure;
	long connectStart;
	long connectFinish = 0;
	boolean shown = false;

	Target(String host) {
	    try {
		address = new InetSocketAddress(InetAddress.getByName(host),
						port);
	    } catch (IOException x) {
		failure = x;
	    }
	}

	void show() {
	    String result;
	    if (connectFinish != 0)
		result = Long.toString(connectFinish - connectStart) + "ms";
	    else if (failure != null)
		result = failure.toString();
	    else
		result = "Timed out";
	    System.out.println(address + " : " + result);
	    shown = true;
	}

    }


    // Thread for printing targets as they're heard from
    //
    static class Printer
	extends Thread
    {
	LinkedList pending = new LinkedList();

	Printer() 
	{
	    setName("Printer");
	    setDaemon(true);
	}

	void add(Target t) 
	{
	    synchronized (pending) {
		pending.add(t);
		pending.notify();
	    }
	}

	public void run() {
	    for (;;) {
		Target t = null;
		synchronized (pending) {
		    try {
			pending.wait();
		    } catch (InterruptedException x) {
			return;
		    }
		    while (pending.size() > 0) {
			t = (Target)pending.removeFirst();
		    }
		}
		t.show();
	    }
	}
    }


    // Thread for connecting to all targets in parallel via a single selector
    // 
    static class Connector
	extends Thread
    {
	Selector sel;
	Printer printer;

	// List of pending targets.  We use this list because if we try to
	// register a channel with the selector while the connector thread is
	// blocked in the selector then we will block.
	//
	LinkedList pending = new LinkedList();

	Connector(Printer pr) throws IOException {
	    printer = pr;
	    sel = Selector.open();
	    setName("Connector");
	}

	// Initiate a connection sequence to the given target and add the
	// target to the pending-target list
	//
	void add(Target t) {
	    SocketChannel sc = null;
	    try {

		// Open the channel, set it to non-blocking, initiate connect
		sc = SocketChannel.open();
		sc.configureBlocking(false);
		sc.connect(t.address);

		// Record the time we started
		t.channel = sc;
		t.connectStart = System.currentTimeMillis();

		// Add the new channel to the pending list
		synchronized (pending) {
		    pending.add(t);
		}

		// Nudge the selector so that it will process the pending list
		sel.wakeup();

	    } catch (IOException x) {
		if (sc != null) {
		    try {
			sc.close();
		    } catch (IOException xx) { }
		}
		t.failure = x;
		printer.add(t);
	    }
	}

	// Process any targets in the pending list
	//
	void processPendingTargets() throws IOException {
	    synchronized (pending) {
		while (pending.size() > 0) {
		    Target t = (Target)pending.removeFirst();

		    // Register the channel with the selector, indicating
		    // interest in connection completion
		    SelectionKey sk;
		    try {
			sk = t.channel.register(sel,
						SelectionKey.OP_CONNECT);
		    } catch (IOException x) {
			t.channel.close();
			t.failure = x;
			printer.add(t);
			continue;
		    }

		    // Attach the target object to the key so that we can get
		    // it back after the key is added to the selector's
		    // selected-key set
		    sk.attach(t);

		}
	    }
	}

	// Process keys that have become selected
	//
	void processSelectedKeys() throws IOException {
	    for (Iterator i = sel.selectedKeys().iterator(); i.hasNext();) {

		// Retrieve the next key and remove it from the set
		SelectionKey sk = (SelectionKey)i.next();
		i.remove();

		// Retrieve the target and the channel
		Target t = (Target)sk.attachment();
		SocketChannel sc = (SocketChannel)sk.channel();

		// Attempt to complete the connection sequence
		try {
		    if (sc.finishConnect()) {
			sk.cancel();
			t.connectFinish = System.currentTimeMillis();
			sc.close();
			printer.add(t);
		    }
		} catch (IOException x) {
		    sc.close();
		    t.failure = x;
		    printer.add(t);
		}
	    }
	}

	volatile boolean shutdown = false;

	// Invoked by the main thread when it's time to shut down
	//
	void shutdown() {
	    shutdown = true;
	    sel.wakeup();
	}

	// Connector loop
	//
	public void run() {
	    for (;;) {
		try {
		    int n = sel.select();
		    if (n > 0)
			processSelectedKeys();
		    processPendingTargets();
		    if (shutdown) {
			sel.close();
			return;
		    }
		} catch (IOException x) {
		    x.printStackTrace();
		}
	    }
	}

    }


    public static void main(String[] args)
	throws InterruptedException, IOException
    {
	if (args.length < 1) {
	    System.err.println("Usage: java Ping [port] host...");
	    return;
	}
	int start = 0；

	try
	{
	    port = Integer.parseInt(args[0]);
	    start = 1;
	}
	catch(Exception e)
	{
	    start = 0;
	}

	// Create the threads and start them up
	Printer printer = new Printer();
	printer.start();
	
	Connector connector = new Connector(printer);
	connector.start();

	// Create the targets and add them to the connector
	LinkedList targets = new LinkedList();
	for (int i = start; i < args.length; i++) {
	    Target t = new Target(args[i]);
	    targets.add(t);
	    connector.add(t);
	}

	// Wait for everything to finish
	Thread.sleep(2000);
	connector.shutdown();
	connector.join();

	// Print status of targets that have not yet been shown
	for (Iterator i = targets.iterator(); i.hasNext();) {
	    Target t = (Target)i.next();
	    if (!t.shown)
		t.show();
	}

    }

}