Java网络编程精解学习笔记(第三章 serverSocket详解)

原创 2017年01月06日 20:07:59
1.构造ServerSocket
ServerSocket的构造方法有以下几种重载方法:
ServerSocket()
ServerSocket(int port)
ServerSocket(int port, int backlog)
ServerSocket(int port, int backlog, InetAddress bindAddr)
参数port表示端口,backlog表示请求队列,IentAddress表示绑定的服务器地址。
a>绑定端口:
除了第一个,其他构造方法都会绑定一个端口,例如:
ServerSocket ss = new ServerSocket(80);
如果绑定失败,则会抛出IOException。更确切来说是BindException,BindException是IOException的子类。绑定失败一般有两个原因:1.该端口已经别某个端口占用。2.用户不是超级管理员,不能绑定1-1023端口。如果端口指定的是0,则系统会默认分配给ServerSocket一个未被占用的匿名端口。由于客户端与服务器端连接需要知道服务器端的端口,所有不建议使用匿名端口。
b>设定客户端连接请求的长度:
当服务器进程运行时,会同时监听多个客户端连接请求。客户端的连接请求是由操作系统管理的,操作系统会把连接请求放入到一个先进先出的队列里,一般操作系统会规定队列的长度(一般是50)。当请求到达队列上限后其他请求就会被拒绝掉。只有当服务器执行serverSocket.accept(),把请求取出后,队列里才能腾出空位加入新的请求。
对于客户端来说,发出的连接请求加入到服务器队列则说明连接成功,客户端的socket构造方法返回。如果连接请求被拒绝,则会抛出ConnectionException。
backlog参数用于显示的指定队列的长度,指定的长度会覆盖操作系统指定的长度。但是有几种情况会依然采用操作系统指定的最大长度:1.backlog的长度大于操作系统指定的长度。2.backlog的长度小于等于0。 3.没有指定backlog参数。
以下例程用于演示连接请求参数:
Client.java:
public class Client {
public static void main(String[] args) throws UnknownHostException, IOException, InterruptedException {
String host = "localhost";
int port = 8000;
Socket[] sockets = new Socket[10];
for(int i=0; i<10; i++) {
sockets[i] = new Socket(host, port);
System.out.println("第"+i+"次连接建立成功");
}
Thread.sleep(3000);
for(Socket s : sockets) {
s.close();
}
}
}
Server.java:
public class Server {
ServerSocket ss = null;
public Server() throws IOException {
ss = new ServerSocket(8000, 3);
System.out.println("服务器启动成功");
}

public void server() throws IOException {
while(true) {
Socket s = null;
try{
s = ss.accept();
System.out.println(s.getInetAddress() + ":" + s.getPort());
}finally {
if(s != null) {
s.close();
}
}
}
}
public static void main(String[] args) throws IOException, InterruptedException {
Server s = new Server();
//Thread.sleep(60000);
s.server();
}
}
如果把s.server()注释掉,由于服务器无法执行serverSocket.accept(),连接请求不被取出,所以请求连接3次后,其他的请求都被拒绝掉。如果打开s.server()。队列中的请求不断被消费,所以所有请求都会成功建立连接。
c>设定绑定的IP地址:
如果服务器只有一个Ip,那么ServerSocket会默认绑定这个IP。如果服务器有多个IP,则可以通过bindAddr这个参数指定绑定哪个IP地址。
d>默认构造方法的作用:
不带参数的构造方法没有绑定任何端口。该构造方法的作用是在绑定端口之前设置ServerSocket的某些属性。因为一旦服务器绑定端口后,某些属性就不能修改了。例如SO_REUSEADDR。
ServerSocket ss = new ServerSocket();
ss.setReuseAddress(true);
ss.bind(new InetSocketAddress(8000));
如果写成:
ServerSocket ss = new ServerSocket(8000);
ss.setReuseAddress(true);则该属性不会生效。

2.接收和关闭与客户的连接:
ServerSocket的accept()方法会从队列中取出一个连接请求,建立一个与客户端连接的Socket对象并且返回。如果队列中没有连接请求,accept()方法就会一直等下去。
接下来服务器从socket对象中获取输入,输出流。与客户端进行数据通信。当服务器端向客户端发送数据时,客户端断开了连接,那么会抛出一个IOException的子类SocketException。这只是服务器与单个客户端通信的连接,该异常应该被捕获,使得不能中断服务器与其他客户端的通信。
以下是单线程服务器采用的通信流程:
public class CloseSocket {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(8000);
while(true) {
Socket s = null;
try {
s = ss.accept();
System.out.println(s.getInetAddress() + ":" + s.getPort());
} catch (IOException e) {
e.printStackTrace();
}finally {
if(s != null) {
s.close();
}
}
}
}

3.关闭ServerSocket:
ServerSocket()调用close()方法会释放占用的端口,断开所有与客户端的连接。如果不显示调用close()方法,当服务器进程结束后系统也会调用close()。所以没有必要再进程结束前调用close()。
在某些情况下,为了及时释放端口,以便让其他进程绑定该端口,可以显示调用close()方法。
serverSocket的isClose()是判断是否调用了close()方法。只有调用了isClose()才返回true。否则即使ServerSocket没有与端口绑定,该方法也返回false。
ServerSocket的isBound()方法判断是否与端口进行了绑定。如果ServerSocket已经与一个端口绑定过,及时它已经被关闭。isBound也返回true。
判断ServerSocket绑定一个端口并且没有被关闭的方法:
serverSocket.isBound() && !serverSocket.isClose();

4.获取ServerSocket的信息:
public InetAddress getInetAddress() //获取服务端IP地址、
public int getLocalPort() //获取服务端端口
构造方法中Port为0时,操作系统就会为ServerSocket分配一个匿名端口,通过getLocalPort就可以获取该端口,例程如下:
public class SocketTest {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(0);
System.out.println(ss.getLocalPort());
}
}
多数的服务器使用固定端口,方便客户端的连接。匿名端口使用与服务器端与客户端的临时通信。通信结束连接断开,并且ServerSocket占用的端口也释放。
FTP用于本地与远程服务器传输文件,它的一种方式使用了匿名端口。FTP使用两条并行的TCP连接,一条控制连接,一条数据连接。控制连接用于传输用户名,密码,修改服务器目录命令,上传下载命令等。数据连接用于上传下载文件用。服务器的控制连接监听在21端口。
数据连接的创建有两种 方式:
1>服务器的数据连接监听在20端口上,客户端主动请求连接到服务器端。
2>客户端首先创建一个监听在匿名端口的serverSocket。然后把这个端口号(通过getLocalPort获取)发送给服务器端。服务器端主动请求连接到客户端。该种方法就使用了serverSocket的匿名端口用于传输临时数据。

5.ServerSocket选项:
a>SO_TIMEOUT
设置该选项:public void setSoTimeout(int timeout)
获取该选项:public int getSoTimeout()
服务器端等待客户端连接的超时时间。服务器端的accept()方法会从连接队列中取请求连接,如果队列为空服务器就会一直等下去,直到到达设定的超时时间为止。如果超时时间设置的是0,表示一直会等待下去,这是ServerSocket的默认值,单位是毫秒。
如果服务器端超出了超时时间就会抛出SocketTimeoutException,它是InterruptedException的子类。例程如下:
public class SocketTimeout {、
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(8000);
ss.setSoTimeout(5000);
Socket s = ss.accept();
s.close();
}
}
b>SO_REUSEADDR选项:
设置该选项:public void setReuseAddress(boolean b)
获取该选项: public boolean getReuseAddress()
该参数表示网络上还有数据没有传送到ServerSocket时,是否允许新的serverSocket绑定到老的ServerSocket上。默认值取决于操作系统,有的操作系统运行,有的不允许。
当网络上还有数据没有发送到ServerSocket上时,当关闭它时先不释放绑定的端口,数据全部接收完后在释放。许多服务器都使用固定端口,当服务器停止后,它所绑定的端口不会立即释放,如果此时重启服务器,由于该端口被占用导致绑定失败,抛出BindException。为了确保服务器停止后,新的进程能立即绑定该端口,可以使用setReuseAddress(true)方法。值得注意的是:该选项在在ServerSocket绑定端口前设置才有效。而且新的和老的ServerSocket同时设置才会起作用。
c>SO_RCVBUF选项:
设置该选项:public void setReceiveBufferSize(int size)
获取该选项:public int getReceiveBufferSize()
该选项用于设置服务器接收数据时的缓冲区大小,单位是字节。如果传输的数据量比较大,则将该选项值设置大些,以减少传输次数提高效率。如果传输的数据量比较少,并且传输较频繁则该选项设置小些。确保及时把数据传送给服务器。该选项的默认值与操作系统有关。
无论在绑定端口前还是绑定端口后设置该选项都有效,但是特殊情况是:当设置的缓冲区大于64K时,需要在绑定端口前设置该选项:
ServerSocket ss = new ServerSocket();
int size = ss.getReceiveBufferSize();
if(size < 131072) ss.setReceiveBufferSize(131072); //设置缓冲区大小为128K
ss.bind(new InetSocketAddress(8000));
执行setReceiveBufferSize选项后, serverSocket.accept()获取的所有Socket对象的缓冲区大小都为设置的值。
d>设置连接时间,带宽,延时的重要性
、设置该选项:public void setPerformancePreferences(int connectionTime, int latency, int bandwidth); 该选项的作用与Socket相同,用于设置连接时间,延时和带宽的相对重要性。

6.创建多线程服务器:
服务器为客户端提供的连接数越多,响应客户端的速度越快,表示服务器的并发性能越高。本节提供了3种并发方法:1.为每个客户端生成一个服务线程。2.使用线程池,由其中的工作线程为客户服务。3.使用JDK提供的线程池。
客户端:
public class Client {
public static void main(String[] args) {
Socket socket = null;
try {
socket = new Socket("localhost", 8000);
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
BufferedReader br = getReader(socket);
PrintWriter pw = getWrite(socket);
String msg = null;
while((msg = in.readLine()) != null) {
System.out.println("client:" + msg);
pw.println(msg);
System.out.println(br.readLine());
if("bye".equals(msg)) {
break;
}
}
}catch(Exception e) {
e.printStackTrace();
}finally {
if(socket != null) {
try {
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
private static BufferedReader getReader(Socket socket) throws IOException {
InputStream is = socket.getInputStream();
return new BufferedReader(new InputStreamReader(is));
}
private static PrintWriter getWrite(Socket socket) throws IOException {
OutputStream os = socket.getOutputStream();
return new PrintWriter(os, true); //注意true参数,否则数据不会马上发送,出现收不到的情况
}
}
a>为每一个客户生产一个服务线程:
public class CreateThreadForEveryClient {
private int port = 8000;
private ServerSocket serverSocket = null;
public CreateThreadForEveryClient() throws IOException {
serverSocket = new ServerSocket(port);
System.out.println("服务器启动成功");
}
public void service() {
Socket socket = null;
try {
socket = serverSocket.accept();
Thread t = new Thread(new Handler(socket)); //每收到一个连接就起一个线程。
t.start();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
new CreateThreadForEveryClient().service();
}
}

class Handler implements Runnable {

public Handler(Socket socket) {
this.socket = socket;
}

private Socket socket = null;
@Override
public void run() {
try {
System.out.println("a client connection:" + socket.getInetAddress() + ":" + socket.getPort());
BufferedReader br = getReader(socket);
PrintWriter pw = getWrite(socket);
String msg = null;
while((msg = br.readLine()) != null) {
System.out.println("server:" + msg);
pw.println(echo(msg));
if("bye".equals(msg)) {
break;
}
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(socket != null) {
try {
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
private BufferedReader getReader(Socket socket) throws IOException {
InputStream is = socket.getInputStream();
return new BufferedReader(new InputStreamReader(is));
}
private PrintWriter getWrite(Socket socket) throws IOException {
OutputStream os = socket.getOutputStream();
return new PrintWriter(os, true);
}
private String echo(String msg) {
return "echo" + msg;
}
}
b>创建线程池:
上面方法为每个客户端分配一个工作线程,通信结束后线程销毁。以上方法不足之处有:
1>如果许多客户端连接服务器。并且每次通信的时间都很短。那么线程创建和销毁的成本比通信成本还要高。
2>活动的线程会消耗系统资源,如内存(每个线程大概消耗1M内存)。为每个客户端分配线程,如果客户端的数量很多,那么分配的工作线程会很多。销毁大量系统资源。
3>如果线程数目固定,并且执行周期很长。那么线程切换(线程切换指线程之间转让cup的使用权)的频率大概是固定的(一般20毫秒左右),如果线程频繁创建销毁,那么它的切换周期也不在固定。因为销毁的线程必须把cup转让给等待中的线程。线程切换的开销甚至比创建,销毁线程的开销还要大。
线程池解决了线程生命周期开销和系统资源不足的问题。线程池会预先生成几个线程。它们不断的从工作队列中取任务,处理完后在取下一个任务。该方法的好处有:1.减少了创建,销毁线程的次数。因为线程程的线程数是固定的。2.可以手工设定线程池的线程个数,从而根据系统资源的情况灵活调整。
如下例程是线程池的一个解决方案:
ThreadPool.java:
public class ThreadPool extends ThreadGroup {
private static int threadPoolId;
private int threadId;
private LinkedList<Runnable> workQueue;
private boolean isClose = false;
public ThreadPool(int threadNum) {
super("thread pool-" + (threadPoolId++));
setDaemon(true);
workQueue = new LinkedList<Runnable>();
for(int i=0; i<threadNum; i++) {
new WorkThread().start();
}
}
//向工作队列中加入一个任务
public synchronized void execute(Runnable task) {
if(isClose == true) {
throw new IllegalStateException();
}
workQueue.add(task);
notify(); //唤醒工作线程取任务
}
//从工作队列中取任务
public synchronized Runnable getTask() throws InterruptedException {
while(workQueue.size() == 0) {
if(isClose) return null;
wait();
}
return workQueue.removeFirst(); //如果队列不空则返回第一个任务
}
//立即关闭线程池
public synchronized void close() {
if(isClose == false) {
isClose = true;
workQueue.clear();
interrupt();
}
}
//所有线程执行完毕后,关闭线程池
public void join() {
synchronized(this) {
isClose = true;
notifyAll();
}
Thread[] threads = new Thread[activeCount()];
int count = enumerate(threads);
for(int i=0; i<count; i++) {
try {
threads[i].join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

private class WorkThread extends Thread {

public WorkThread() {
super(ThreadPool.this, "thread:" + threadId++);
}
@Override
public void run() {
Runnable task = null;
while(!isInterrupted()) {
try {
task = getTask();
} catch (InterruptedException e) {
}
if(task == null) return; //如果task==null,或者抛出异常则返回。
task.run(); //取出任务,执行任务。
}
}
}
}
ThreadPoolTest.java:
public class ThreadPoolTest {

public static void main(String[] args) {
ThreadPool threadPool = new ThreadPool(3);
for(int i=0; i<5; i++) {
threadPool.execute(createTask(i));
}
threadPool.join();
}
public static Runnable createTask(final int taskId) {
return new Runnable() {
@Override
public void run() {
System.out.println("task"+taskId+":start");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("task"+taskId+":end");
}
};
}
}
c>使用JDK提供的线程池:
java.util.concurrent包提供了现成的线程池,Executor接口表示线程池,它的execute(Runnable task)方法用来执行Runnable类型的任务。 ExecutorService是Executor的子类,它提供了对线程池的一些操作,如shutdown()方法等。Executors提供了一些静态方法,用来生成ExecutorService实例。Executors生成的实例如下:
1>newCachedThreadPool():只有任务时才生成实例,空闲实例存活60S
2>newFixedThreadPool(int threads): 线程池中含有固定数目的线程,线程不会销毁。threads表示线程的个数。
3>newSingleThreadExecutor():只有一个线程,它依次执行每个任务。
4>newScheduleThreadPool(int corePoolSize): 线程会按照时间计划来执行任务。corePoolSize表示最小的线程数,当线程不足时可以创建线程。
5>newSingleThreadScheduleExecutor():线程池中只有一个线程,它会按照时间计划执行任务。
使用JDK的线程池例程如下:
public class JDKThreadPoolServer {
private int port = 8000;
private ServerSocket serverSocket = null;
private ThreadPool threadPool;
private final int POOL_SIZE = 4;
private ExecutorService executorService;
public JDKThreadPoolServer() throws IOException {
serverSocket = new ServerSocket(port);
executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
System.out.println("服务器启动成功");
}
public void service() {
Socket socket = null;
try {
socket = serverSocket.accept();
executorService.execute(new Handler(socket));
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
new JDKThreadPoolServer().service();
}
}

class Handler implements Runnable {

public Handler(Socket socket) {
this.socket = socket;
}

private Socket socket = null;
@Override
public void run() {
try {
System.out.println("a client connection:" + socket.getInetAddress() + ":" + socket.getPort());
BufferedReader br = getReader(socket);
PrintWriter pw = getWrite(socket);
String msg = null;
while((msg = br.readLine()) != null) {
System.out.println("server:" + msg);
pw.println(echo(msg));
if("bye".equals(msg)) {
break;
}
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(socket != null) {
try {
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
private BufferedReader getReader(Socket socket) throws IOException {
InputStream is = socket.getInputStream();
return new BufferedReader(new InputStreamReader(is));
}
private PrintWriter getWrite(Socket socket) throws IOException {
OutputStream os = socket.getOutputStream();
return new PrintWriter(os, true);
}
private String echo(String msg) {
return "echo" + msg;
}
}
d>使用线程池的注意事项:


版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Java网络编程学习笔记(3)ServerSocket用法详解

ServerSocket用法详解 ServerSocket负责接受客户端连接请求 ServerSocket构造: ServerSocket()         ServerSocket(in...

Java网络编程精解笔记3:ServerSocket详解

http://www.blogjava.net/landon/archive/2013/07/27/401911.html#402030 ServerSocket用法详解  1.C/S...

Java网络编程精解之ServerSocket用法详解二

从上节提到Server端负责接收Client连接,以及与客户端通信,具体代码: while (true) { Socket socket=null; try { socke...

java网络编程精解学习笔记(第二章 socket详解)

1 构造socket socket有几个重载的构造方法: Socket() Socket(InetAddress address, int port) //第一个参数表示主机的IP地址 Soc...
  • cg3410
  • cg3410
  • 2017年01月06日 20:06
  • 160

Java网络编程精解之ServerSocket用法(部分)

转载地址:http://www.51cto.com/art/200702/40204_3.htm

Java笔记(9)-网络编程、URL、InetAddress、套接字、Socket、ServerSocket、多线程、UDP、广播数据包、远程调用

不必说碧绿的菜畦,光滑的石井栏,高大的皂荚树,紫红的桑葚;也不必说鸣蝉在树叶里长吟,肥胖的黄蜂伏在菜花上,轻捷的叫天子(云雀)忽然从草间直窜向云霄里去了。 Java网络编程 URL 类 InetAd...

java网络编程精解学习笔记(第一章 网络基础)

网络编程的基础任务是:开发客户端,服务器程序,使两者有条不紊的交换数据。 1.1进程就是执行中的程序,进程的任务就是执行程序中的代码。如下程序示例: public clas...
  • cg3410
  • cg3410
  • 2016年12月26日 11:36
  • 254

java 网络编程之ServerSocket详解

构造ServerSocket  : 在客户/服务器通信模式中,服务器需要创建创建监听特定端口的ServerSocket。负责接收客户连接请求。 如果在构造方法运行过程中 如果无法绑定到指定的端口上...

java网络编程 serverSocket编程讲解

  • 2010年05月14日 10:44
  • 299KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java网络编程精解学习笔记(第三章 serverSocket详解)
举报原因:
原因补充:

(最多只允许输入30个字)