java的serversocket_Java ServerSocket详解

ServerSocket

构造方法

ServerSocket serverSocket = new ServerSocket();

ServerSocket();//无参数

ServerSocket(int port);//指定端口

ServerSocket(int port,int backlog);//指定端口、队列数

ServerSocket(int port,int backlog,InetAddress bindAddr);//指定端口、队列数、绑定IP

注：当port为0时，随机分配空闲端口。

无参数绑定端口

serverSocket.bind(SocketAddress endpoint);//指定端口

serverSocket.bind(SocketAddress endpoint,int backlog)//指定端口、队列数

ServerSocket选项

SO_TIMEOUT：等待客户连接的超时时间

serverSocket.setSoTimeout(int timeout);//设置(单位为毫秒，为0，则永不超时)

serverSocket.getSoTimeout();//查看超时时间

SO_REUSEADDR：是否允许重用服务器所绑定的地址(需在连接前设置)

serverSocket.setResuseAddress(boolean on);//设置

serverSocket.getResuseAddress();//查看是否开启

SO_RCVBUF：接收数据的缓冲区大小

serverSocket.setReceiveBufferSize(int size);//设置

serverSocket.getReceiveBufferSize();//查看缓冲区大小

设定连接时间、延迟和带宽

参数(相对权重)

三个参数之间的相对大小决定相应参数的相对重要性。

connectionTime：最少时间建立连接

latency：最小延迟

bandwidth：最高带宽

serverSocket.setPerformancePreferences(int connectionTime,int latency,int bandwidth);//设置

ServerSocket信息

serverSocket.getInetAddress();//获取服务器绑定的IP

serverSocket.getLocalPort();//获取服务器绑定的端口

多线程

为每一个连接创建一个线程

重写Runnable方法

Handler.java

package Network_3;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.net.Socket;

public class Handler implements Runnable {

private Socket socket = null;//初始化Socket

public Handler(Socket socket) {

this.socket = socket;//传入参数

}

/*

*输出流

*/

public PrintWriter getWriter(Socket socket) throws IOException {

OutputStream socketOut = socket.getOutputStream();

return new PrintWriter(socketOut,true);

}

/*

*输入流

*/

public BufferedReader getReader(Socket socket) throws IOException {

InputStreamReader socketIn = new InputStreamReader(socket.getInputStream());

return new BufferedReader(socketIn);

}

//加工信息

public String Echo(String msg) {

return “Echo：”+msg;

}

public void run() {

try {

System.out.println(“New Connection “+socket.getInetAddress()+”：”+socket.getPort());//打印新连接信息

BufferedReader br = getReader(socket);//输入流

PrintWriter pw = getWriter(socket);//输出流

String msg = null;//初始化msg

while((msg = br.readLine()) != null) {//循环读取一行信息

System.out.println(msg);//打印信息

pw.println(Echo(msg));//将信息加工发送回客户端

if(msg.equals(“exit”)) {//结束条件

break;

}

}

} catch (IOException e) {

e.printStackTrace();

}finally {

try {

if(socket != null) {//如有连接，关闭

socket.close();

}

}catch (Exception e) {

e.printStackTrace();

}

}

}

}

Server.java

package Network_3;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

public class Server {

private int port = 8000;//初始化port

private ServerSocket serverSocket = null;//初始化ServerSocket

public Server() {

try {

serverSocket = new ServerSocket(port);//启动服务端

System.out.println(“Server Up!”);

} catch (IOException e) {

System.out.println(“Server Up Error!”);

}

}

public void service() {

while(true) {

Socket socket = null;//初始化Socket

try {

socket = serverSocket.accept();//监听连接队列

Thread workThread = new Thread(new Handler(socket)); //创建线程

workThread.start();//启动线程

}catch (Exception e) {

e.printStackTrace();

}

}

}

public static void main(String[] args) {

new Server().service();

}

}

Client.java

package Network_3;

import java.net.*;

import java.io.*;

public class Client {

/*

* 参数初始化

*/

private String host = “127.0.0.1”;

private int port = 8000;

private Socket socket;

/*

* 建立连接

*/

public Client() throws IOException {

socket = new Socket(host,port);

}

/*

* 输出流

*/

private PrintWriter getWriter(Socket socket) throws IOException {

OutputStream socketOut = socket.getOutputStream();

return new PrintWriter(socketOut,true);

}

/*

* 输入流

*/

private BufferedReader getReader(Socket socket) throws IOException {

InputStreamReader socketIn = new InputStreamReader(socket.getInputStream());

return new BufferedReader(socketIn);

}

/*

* 客户程序

*/

public void Talk() {

try {

BufferedReader br = getReader(socket);

PrintWriter pw = getWriter(socket);

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

String msg = null;

while((msg = localReader.readLine()) != null) {

pw.println(msg);

System.out.println(br.readLine());

if(msg.equals(“exit”)) {

break;

}

}

}catch (Exception e) {

e.printStackTrace();

}finally {

try {

socket.close();

}catch (Exception e) {

e.printStackTrace();

}

}

}

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

new Client().Talk();

}

}

使用JDK类库提供的线程池

java.util.concurrent包提供

Server.java

package Network_3;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class Server {

private int port = 8000;//初始化port

private ServerSocket serverSocket = null;//初始化ServerSocket

private ExecutorService executorService = null;//初始化线程池

private final int POOL_SIZE = 4;//单个CPU的线程数

public Server() throws IOException {

serverSocket = new ServerSocket(port);

executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);//创建线程池，Runtime.getRuntime().availableProcessors()用于返回当前工作环境的CPU数，将CPU数乘单个CPU线程数，得到最终的总线程数。

System.out.println(“Server Up”);

}

public void service() {

while(true) {

Socket socket = null;

try {

socket = serverSocket.accept();

executorService.execute(new Handler(socket));//Handler与上面的一样

}catch (Exception e) {

e.printStackTrace();

}

}

}

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

new Server().service();

}

}

注意事项

死锁

建议：尽量减少任务之间的依赖。

系统资源不足

建议：根据系统性能设定线程数，回收机制。

并发错误

建议：使用成熟的线程技术。

线程泄露

建议：执行线程任务时，减少与用户的交互(使用超时机制)。

任务过载

建议：控制线程等待队列中的线程数。

关闭服务器

开放一个管理服务器端口，启动守护线程，供管理程序连接，当发送特定字符时，服务器停止向线程池添加任务并等待任务执行完毕或超时，关闭服务程序。

Server.java

package Network_3;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.SocketException;

import java.net.SocketTimeoutException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.RejectedExecutionException;

import java.util.concurrent.TimeUnit;

public class Server {

private int port = 8000;//服务端口

private ServerSocket serverSocket = null;//服务Socket

private ExecutorService executorService = null;//线程池

private final int POOL_SIZE = 4;//单个CPU的线程数

private int portForShutdown = 8001;//守护线程端口

private ServerSocket serverSocketForShutdown = null;//守护Socket

private boolean isShutdown = false;//服务器是否关闭

private Thread shutDownThread = new Thread() {//负责关闭服务器的线程

public void start() {

this.setDaemon(true);//设置为守护线程(后台线程)

super.start();

}

public void run() {

while(!isShutdown) {

Socket socketForShutdown = null;

try {

socketForShutdown = serverSocketForShutdown.accept();//开启监听

//获取输入流

BufferedReader br = new BufferedReader(new InputStreamReader(socketForShutdown.getInputStream()));

String command = br.readLine();//读取一行字符

if(command.equals(“shutdown”)) {//判断是否符合指定字符

long beginTime = System.currentTimeMillis();//开始计数

//输出流输出字符

socketForShutdown.getOutputStream().write(“Server Shutdowning\r\n”.getBytes());

//服务器关闭

isShutdown = true;

//不再向线程池添加新线程

executorService.shutdown();

//所有任务是否已完成

while(!executorService.isTerminated()) {

//设置线程池中任务的完成超时时间

executorService.awaitTermination(30, TimeUnit.SECONDS);

}

//关闭服务器

serverSocket.close();

long endTime = System.currentTimeMillis();//结束计数

//输出流输出字符

socketForShutdown.getOutputStream().write((“Server Shutdown\r\nTime：”+(endTime-beginTime)+”ms\r\n”).getBytes());

//关闭守护线程

socketForShutdown.close();

serverSocketForShutdown.close();

}else {

//不符合特定字符

socketForShutdown.getOutputStream().write(“Error”.getBytes());

socketForShutdown.close();

}

}catch (Exception e) {

e.printStackTrace();

}

}

}

};

public Server() throws IOException {

//创建Socket

serverSocket = new ServerSocket(port);

serverSocket.setSoTimeout(60000);//设置超时时间

//创建守护Socket

serverSocketForShutdown = new ServerSocket(portForShutdown);

//创建线程池

executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);

//运行守护线程

shutDownThread.start();

System.out.println(“Server Up”);

}

public void service() {

while(!isShutdown) {

Socket socket = null;

try {

socket = serverSocket.accept();

socket.setSoTimeout(60000);

executorService.execute(new Handler(socket));

}catch (SocketTimeoutException e) {

System.out.println(“Client Timeout”);

}catch (RejectedExecutionException e) {

try {

if(socket != null) {

socket.close();

}

}catch (IOException x) {

return;

}

}catch (SocketException e) {

if(e.getMessage().indexOf(“socket closed”) != -1) {

return;

}

}catch (IOException e) {

e.printStackTrace();

}

}

}

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

new Server().service();

}

}

AdminClient.java

package Network_3;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.net.Socket;

public class AdminClient {

public static void main(String[] args) {

Socket socket = null;

try {

socket = new Socket(“localhost”, 8001);

OutputStream socketOut = socket.getOutputStream();

socketOut.write(“shutdown\r\n”.getBytes());

BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

String msg = null;

while((msg = br.readLine()) != null) {

System.out.println(msg);

}

}catch (Exception e) {

e.printStackTrace();

}finally {

try {

if(socket != null) {

socket.close();

}

}catch (Exception e) {

e.printStackTrace();

}

}

}

}