java socket 模拟,JAVA Socket模拟简单的通讯（代码实例），javasocket

JAVA Socket模拟简单的通讯(代码实例)，javasocket

依旧使用bio流。

使用线程池技术，管理服务器线程。

实现服务器关机处理，解决大部分异常处理。

package xin.tomdonkey.net.bio;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

public class Server

{

/**

* 循环标记，是否执行接受新连接的标记

* 仅标记是否接受新连接，不标记其他状态

*/

private int port;

private boolean life;

private ServerSocket serverSocket ;

private ExecutorService threadPool = Executors.newCachedThreadPool();

public void startup()

{

while (life)

{

try

{

Socket socket = serverSocket.accept();

threadPool.submit(new ServerClient(socket));

System.out.println("一个新任务进入线程池");

System.out.println("当前线程池为：" + threadPool);

}

catch (IOException e)

{

System.err.println("serverSocket被关闭了，主循环解除阻塞");

}

}

}

public void shutDown()

{

life = false;

System.err.println("主循环退出");

try

{

serverSocket.close();

}

catch (IOException e)

{

e.printStackTrace();

}

shutdownAndAwaitTermination(threadPool);

System.err.println("系统正常退出");

}

/**

* 此方法一定无法终止此程序下正在运行的线程，

* 此方法只能让能响应interrupt的线程终止

* 而此程序下使用的是bio，并不会抛出interrupt

* 故而只会等待线程10s执行时间，为执行完成，直接终止程序。

* @param pool

*/

private void shutdownAndAwaitTermination(ExecutorService pool)

{

pool.shutdown();

try

{

if (!pool.awaitTermination(5, TimeUnit.SECONDS))

{

pool.shutdownNow();

if (!pool.awaitTermination(5, TimeUnit.SECONDS))

{

System.err.println("线程池中存在无法被关闭的线程...");

System.err.println("系统强制关闭...");

System.exit(-1);

}

}

}

catch (InterruptedException ie)

{

pool.shutdownNow();

Thread.currentThread().interrupt();

}

}

/**

* 采用默认端口6655创建服务器

*

* @throws IOException

*/

public Server() throws IOException

{

this(6655);

}

/**

* 指定端口port创建服务器

*

* @param port 服务器监听的端口

* @throws IOException

*/

public Server(int port) throws IOException

{

this.port = port;

this.life = true;

this.serverSocket = new ServerSocket(port);

}

public static void main(String[] args) throws IOException

{

Server server = new Server();

new Thread(()->{

try

{

Thread.sleep(20000);

}

catch (InterruptedException e)

{

e.printStackTrace();

}

server.shutDown();

}).start();

server.startup();

}

}

package xin.tomdonkey.net.bio;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

import java.util.Random;

public class ServerClient implements Runnable

{

private boolean flag;

private InputStream inputStream ;

private OutputStream outputStream ;

public ServerClient(Socket socket)

{

flag = true;

try

{

this.inputStream = socket.getInputStream();

this.outputStream = socket.getOutputStream();

}

catch (IOException e)

{

flag = false;

System.err.println("服务器获取输入输出流时，socket出现异常，run方法将执行空语句，直接退出线程");

}

}

@Override

public void run()

{

while (flag)

{

try

{

//线程启动，即阻塞，直到客户端发出数据

//可以做一个优化，收不到数据即销毁当前线程以及链接和流

int r= inputStream.read();

System.out.println("服务器收到：" + r);

//收到后即回复给客户端一个随机值

byte b = (byte)new Random().nextInt(100);

outputStream.write(b);

System.out.println("服务器写出：" + b);

System.out.println("完成一次回复\n");

}

catch (IOException e)

{

//客户端掉线了,或者IO出现问题抛出此异常，让此线程运行终止

System.out.println("由于客户端发生异常，关闭此服务线程");

flag = false;

}

}

}

}

package xin.tomdonkey.net.bio;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

import java.util.Random;

public class Client

{

Socket socket ;

boolean flag = false;

InputStream inputStream ;

OutputStream outputStream ;

public Client(String address,int port) throws IOException

{

this.socket = new Socket(address,port);

this.inputStream = socket.getInputStream();

this.outputStream = socket.getOutputStream();

}

public void startup() throws IOException, InterruptedException

{

flag = true;

while (flag)

{

//由客户端发起，向服务器写出数据，一个随机byte值

byte b = (byte)new Random().nextInt(100);

outputStream.write(b);

System.out.println("写出：" + b);

//写出完成之后，线程阻塞，直到收到服务器发来的值为止

int r = inputStream.read();

System.out.println("收到：" + r);

System.out.println("完成一次请求\n");

//收到之后线程休眠2s，再向服务器写出数据

Thread.sleep(2000);

}

}

public static void main(String[] args) throws IOException, InterruptedException

{

Client client = new Client("127.0.0.1",6655);

client.startup();

}

}