1. socket通信：有客户端和服务端的socket代码。

　　2. 多线程：客户端和服务端各用一线程发送信息；服务端另有一监听线程，用于把超时的信息删除。

　　这里应用到了同步，使两个线程可以操作同一个map。

　　代码：（类全在同一个包内）

　　server端：

　　import java.io.BufferedReader;

　　import java.io.InputStreamReader;

　　import java.io.PrintWriter;

　　import java.net.ServerSocket;

　　import java.net.Socket;

　　import java.util.Collections;

　　import java.util.concurrent.TimeUnit;

　　import java.util.HashMap;

　　import java.util.Map;

　　public class ServerNet {

　　// 以毫秒为单位

　　private final static long timeLimit = 10000 ;

　　private Map<String,String> map = Collections.synchronizedMap(new HashMap<String,String>());

　　public void ServerSocketNet(){

　　try{

　　ServerSocket ss = new ServerSocket(6060);

　　Socket s = ss.accept();

　　// 用于获取客户端传输来的信息

　　BufferedReader buff = new BufferedReader(new InputStreamReader(s.getInputStream()));

　　// 用于获取服务端准备响应的信息

　　BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

　　// 发送服务端准备响应的信息

　　PrintWriter pw = new PrintWriter(s.getOutputStream(),true);

　　pw.println("您已经成功建立连接!");

　　new ServerOutNet(pw, in);

　　new ServerTimeListener(map, timeLimit);

　　// 显示客户端的传输来的信息

　　while(true){

　　String str = buff.readLine();

　　if(str.equals("exit")){

　　break;

　　}else{

　　map.put(ServerHelper.getInstance().getMapKey(), str);

　　System.out.println(str + "     map.size: " + map.size());

　　}

　　System.out.println("To Client:");

　　Thread.sleep(100);

　　}

　　s.close();

　　}catch(Exception e){

　　e.printStackTrace();

　　}

　　}

　　public static void main(String[] args){

　　new ServerNet().ServerSocketNet();

　　}

　　}

　　/**

　　* server发送线程 向客户端发送响应信息

　　* @author ids-user

　　*

　　*/

　　class ServerOutNet extends Thread{

　　private PrintWriter printWriter;

　　private BufferedReader bufferedReader;

　　ServerOutNet(PrintWriter pw,BufferedReader in){

　　this.printWriter = pw;

　　this.bufferedReader = in;

　　start();

　　}

　　public void run(){

　　while(true){

　　try{

　　String inStr = bufferedReader.readLine();

　　if(inStr.equals("exit")){

　　printWriter.close();

　　bufferedReader.close();

　　break;

　　}else{

　　printWriter.println("From Server: " + inStr);

　　}

　　sleep(300);

　　}catch(Exception e){

　　printWriter = null;

　　bufferedReader = null;

　　throw new RuntimeException(e);

　　}

　　}

　　}

　　}

　　// 时间监听线程类。

　　class ServerTimeListener extends Thread{

　　private long timeLimit;

　　Map<String, String> map = new HashMap<String, String>();

　　// 单例

　　// private ServerTimeListener(){}

　　// private final static ServerTimeListener stl = new ServerTimeListener();

　　// public static ServerTimeListener getInstance(){

　　//   return stl;

　　// }

　　ServerTimeListener(Map<String, String> map , long timeLimit){

　　this.map = map;

　　this.timeLimit = timeLimit;

　　start();

　　} [NextPage]

　　public void run(){

　　while(true){

　　try{

　　// 循环map

　　long currentTime = System.currentTimeMillis();

　　for(String mapKey : map.keySet()){

　　long oldTime = Long.parseLong(mapKey.substring(0, mapKey.indexOf("_")));

　　System.out.println("currentTime - oldTime=" + (currentTime - oldTime));

　　if(currentTime - oldTime >= timeLimit){

　　map.remove(mapKey);

　　}

　　}

　　TimeUnit.MILLISECONDS.sleep(timeLimit);

　　}catch(Exception e){

　　throw new RuntimeException(e);

　　}

　　}

　　}

　　}

　　服务器端辅助类：ServerHelper

　　import java.util.Random;

　　public class ServerHelper {

　　// 单例

　　private ServerHelper(){ }

　　private final static ServerHelper helper = new ServerHelper();

　　public static ServerHelper getInstance(){

　　return helper;

　　}

　　// 构建map的key值

　　public String getMapKey(){

　　Random random = new Random();

　　String mapKey = System.currentTimeMillis() + "_" + random.nextInt(1000);

　　System.out.println("map key: " + mapKey);

　　return mapKey;

　　}

　　}

　　Client端：

　　import java.io.BufferedReader;

　　import java.io.InputStreamReader;

　　import java.io.PrintWriter;

　　import java.net.Socket;

　　import java.util.concurrent.Executors;

　　import java.util.concurrent.ExecutorService;

　　public class ClientNet {

　　public static void main(String[] args){

　　try{

　　Socket s = new Socket("127.0.0.1",6060);

　　// 用于获取服务端传输来的信息

　　BufferedReader buff = new BufferedReader(new InputStreamReader(s.getInputStream()));

　　// 用于获取客户端准备响应的信息

　　BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

　　// 发送客户端准备传输的信息

　　PrintWriter printWriter = new PrintWriter(s.getOutputStream(),true);

　　printWriter.println("有客房端请求连接!");

　　// 客户端使用线程池连接服务端

　　//     ExecutorService executorService = Executors.newCachedThreadPool();

　　//     executorService.execute(new ClientOutNet(printWriter,bufferedReader));

　　new ClientOutNet(printWriter,bufferedReader);

　　while(true){ // 显示服务端的响应信息

　　String str = buff.readLine();

　　if(str != null){

　　System.out.println(str);

　　}

　　//       System.out.println("To Server:");

　　Thread.sleep(100);

　　}

　　}catch(Exception e){

　　e.printStackTrace();

　　}

　　}

　　}

　　/**

　　* Client 发送线程 ，向服务端发送信息

　　* @author ids-user

　　*/

　　class ClientOutNet extends Thread{

　　private PrintWriter printWriter;

　　private BufferedReader bufferedReader;

　　ClientOutNet(PrintWriter pw,BufferedReader in){

　　this.printWriter = pw;

　　this.bufferedReader=in;

　　start();

　　}

　　public void run(){

　　while(true){

　　try{

　　String inStr = bufferedReader.readLine();

　　if(inStr.equals("exit")){

　　printWriter.close();

　　bufferedReader.close();

　　break;

　　}else{

　　printWriter.println("From Client: " + inStr);

　　}

　　sleep(300);

　　}catch(Exception e){

　　printWriter = null;

　　bufferedReader = null;

　　throw new RuntimeException(e);

　　}

　　}

　　}

　　}