没有雪的城市

client
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;

/**
 * @author ylkang
 *
 */
public class Client {
 public SocketChannel client = null;
 public InetSocketAddress isa = null;
 public RecvThread rt = null;
 private String host;
 private int port;

 public Client(String host, int port) {
  this.host = host;
  this.port = port;
 }

 public void makeConnection() {
//  String proxyHost = "192.168.254.212";
//  String proxyPort = "1080";
//  System.getProperties().put("socksProxySet", "true");
//  System.getProperties().put("socksProxyHost", proxyHost);
//  System.getProperties().put("socksProxyPort", proxyPort);
  int result = 0;
  try {
   client = SocketChannel.open();
   isa = new InetSocketAddress(InetAddress.getLocalHost(), port);
   client.connect(isa);
   client.configureBlocking(false);
   receiveMessage();
  } catch (UnknownHostException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
  long begin = System.currentTimeMillis();
  sendMessage();
  long end = System.currentTimeMillis();
  long userTime = end - begin;
  System.out.println("use tiem: " + userTime);
  try {
   interruptThread();
   client.close();
   System.exit(0);
  } catch (IOException e) {
   e.printStackTrace();
  }
 }

 public int sendMessage() {
  System.out.println("Inside SendMessage");
  String msg = null;
  ByteBuffer bytebuf;
  int nBytes = 0;
  try {
   msg = "It's message from client!";
   System.out.println("msg is " + msg);
   bytebuf = ByteBuffer.wrap(msg.getBytes());
   for (int i = 0; i < 1000; i++) {
    nBytes = client.write(ByteBuffer.wrap(((new String((bytebuf.array())) + i + "--")).getBytes()));
    System.out.println(i + " finished");
   }
   interruptThread();
   try {
    Thread.sleep(5000);
   } catch (Exception e) {
    e.printStackTrace();
   }
   client.close();
   return -1;
  } catch (IOException e) {
   e.printStackTrace();
  }
  return nBytes;
 }

 public void receiveMessage() {
  rt = new RecvThread("Receive THread", client);
  rt.start();
 }

 public void interruptThread() {
  rt.val = false;
 }

 public static void main(String args[]) {
  if (args.length < 2) {
   System.err.println("You should put 2 args: host,port");
  } else {
   String host = args[0];
   int port = Integer.parseInt(args[1]);
   Client cl = new Client(host, port);
   cl.makeConnection();
  }
  BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
  String msg;
 }

 public class RecvThread extends Thread {
  public SocketChannel sc = null;
  public boolean val = true;

  public RecvThread(String str, SocketChannel client) {
   super(str);
   sc = client;
  }

  public void run() {
   int nBytes = 0;
   ByteBuffer buf = ByteBuffer.allocate(2048);
   try {
    while (val) {
     while ((nBytes = nBytes = client.read(buf)) > 0) {
      buf.flip();
      Charset charset = Charset.forName("us-ascii");
      CharsetDecoder decoder = charset.newDecoder();
      CharBuffer charBuffer = decoder.decode(buf);
      String result = charBuffer.toString();
//      System.out.println("the server return: " + result);
      buf.flip();
     }
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
 }
}

server

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.util.Iterator;
import java.util.Set;

public class NonBlockingServer {
 public Selector sel = null;
 public ServerSocketChannel server = null;
 public SocketChannel socket = null;
 public int port = 4900;
 String result = null;

 public NonBlockingServer() {
  System.out.println("Inside default ctor");
 }

 public NonBlockingServer(int port) {
  System.out.println("Inside the other ctor");
  this.port = port;
 }

 public void initializeOperations() throws IOException, UnknownHostException {
  System.out.println("Inside initialization");
  sel = Selector.open();
  server = ServerSocketChannel.open();
  server.configureBlocking(false);
  InetAddress ia = InetAddress.getLocalHost();
  InetSocketAddress isa = new InetSocketAddress(ia, port);
  server.socket().bind(isa);
 }

 public void startServer() throws IOException {
  System.out.println("Inside startserver");
  initializeOperations();
  System.out.println("Abt to block on select()");
  SelectionKey acceptKey = server.register(sel, SelectionKey.OP_ACCEPT);
  while (acceptKey.selector().select() > 0) {
   Set readyKeys = sel.selectedKeys();
   Iterator it = readyKeys.iterator();
   while (it.hasNext()) {
    SelectionKey key = (SelectionKey) it.next();
    it.remove();
    if (key.isAcceptable()) {
//     System.out.println("Key is Acceptable");
     ServerSocketChannel ssc = (ServerSocketChannel) key
       .channel();
     socket = (SocketChannel) ssc.accept();
     socket.configureBlocking(false);
     SelectionKey another = socket.register(sel,
       SelectionKey.OP_READ | SelectionKey.OP_WRITE);
    }
    if (key.isReadable()) {
//     System.out.println("Key is readable");
     String ret = readMessage(key);
     if (ret.length() > 0) {
      writeMessage(socket, ret);
     }
    }
    if (key.isWritable()) {
//     System.out.println("THe key is writable");
     String ret = readMessage(key);
     socket = (SocketChannel) key.channel();
     if (result.length() > 0) {
      writeMessage(socket, ret);
     }
    }
   }
  }
 }

 public void writeMessage(SocketChannel socket, String ret) {
  System.out.println("Inside the loop");
  if (ret.equals("quit") || ret.equals("shutdown")) {
   return;
  }
  try {
   String s = "This is content from server!-----------------------------------------";
   System.out.println(ret);
   Charset set = Charset.forName("us-ascii");
   CharsetDecoder dec = set.newDecoder();
   CharBuffer charBuf = dec.decode(ByteBuffer.wrap(s.getBytes()));
   System.out.println(charBuf.toString());
   int nBytes = socket.write(ByteBuffer.wrap((charBuf.toString())
     .getBytes()));
   System.out.println("nBytes = " + nBytes);
   result = null;
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 public String readMessage(SelectionKey key) {
  int nBytes = 0;
  socket = (SocketChannel) key.channel();
  ByteBuffer buf = ByteBuffer.allocate(1024);
  try {
   nBytes = socket.read(buf);
   buf.flip();
   Charset charset = Charset.forName("us-ascii");
   CharsetDecoder decoder = charset.newDecoder();
   CharBuffer charBuffer = decoder.decode(buf);
   result = charBuffer.toString();
  } catch (IOException e) {
   e.printStackTrace();
  }
  return result;
 }

 public static void main(String args[]) {
  NonBlockingServer nb;
  if (args.length < 1) {
   nb = new NonBlockingServer();
  } else {
   int port = Integer.parseInt(args[0]);
   nb = new NonBlockingServer(port);
  }
  try {
   nb.startServer();
   System.out.println("the nonBlocking server is started!");
  } catch (IOException e) {
   e.printStackTrace();
   System.exit(-1);
  }
//  System.out.println("It's message from client!".getBytes());
 }
}