java静态map 多线程_java socket和多线程（Thread）实例

[Socket的多线程通信 java 代码 package  com.wangtong.network;       import  java.io.BufferedReader;    import  java.io.IOException;    import  java.

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

2. 多线程：客户端和服务端各用一线程发送信息；服务端另有一监听线程，[    java网络编程 多线程服务器与客户端系统架构 socket应用     最近在做一些金融业管理系统，经常要进行网络间数据的交互，其实也就是服务器端与客户端的一些信息发送用于把超时的信息删除。

这里应用到了同步，使两个线程可以操作同一个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 map = Collections.synchronizedMap(new HashMap());

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 map = new HashMap();

// 单例

//private ServerTimeListener(){}

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

//public static ServerTimeListener getInstance(){

//return stl;

//}

ServerTimeListener(Map 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);

}

}

}

}

[ Java Thread 多线程 介绍 线程的概述 线程和进程 进程的特征 并发和并行 多线程的优势 1、线程概述     几乎所有的操作系统都支持同时运行多个任务，一个任务通