java socket和多线程（Thread）实例

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();
	}


	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);
			}
		}
	 }
}