关于Java中的ServerSocket类与构造服务器的解析

本文整理于网络材料：http://www.360doc.com/content/13/0327/19/7891085_274308578.shtml

ServerSocket的构造方法有以下几种重载形式：

ServerSocket() throws IOException
ServerSocket(int port) throws IOException
ServerSocket(int port, int backlog) throws IOException
ServerSocket(int port, int backlog, InetAddress bindAddr) throws IOException


在以上构造方法中，参数port指定服务器要绑定的端口（服务器要监听的端口），参数backlog指定客户连接请求队列的长度，参数bindAddr指定服务器要绑定的IP地址。


设定客户连接请求队列的长度
当服务器进行运行时，可能会同时监听到多个客户的连接请求，管理客户连接请求的任务是由操作系统来完成的。操作系统把这些连接请求存储在一个先进先出的队列中。许多操作系统限定了队列的最大长度，一般为50.当队列中的连接请求达到了队列的最大容量时，服务器进程躲在的主机会拒绝新的连接请求。只有当服务器进程通过ServerSocket的accpet()方法从队列中取出连接请求，使队列腾出空位时，队列才能继续加入新的连接请求。


对于客户进程，如果它发出的连接请求被加入到服务器的队列中，就意味着客户与服务器的连接建立成功，客户进程从Socket构造方法中正常返回。如果客户进程发出的连接请求被服务器拒绝，Socket构造方法就会抛出ConnectionException。


ServerSocket构造方法的backlog参数用来显式设置连接请求队列的长度，它将覆盖操作系统限定的队列的最大长度。值得注意的是，在以下几种情况中，仍然会采用操作系统限定的队列的最大长度：
backlog参数的值大于操作系统限定的队列的最大长度；
backlog参数的值小于或等于0；
在ServerSocket构造方法中没有设置backlog参数。


设定绑定的IP地址
如果主机只有一个IP地址，那么默认情况下，服务器程序就与该IP地址绑定。ServerSocket的第4个构造方法ServerSocket(int port, int backlog, InetAddress bindAddr)有一个bindAddr参数，它显式指定服务器要绑定的IP地址，该构造方法适用于具有多个IP地址的主机。


默认构造方法的作用
ServerSocket有一个不带参数的默认构造方法。通过该方法创建的ServerSocket不与任何端口绑定，接下来还需要通过bind()方法与特定端口绑定。这么默认构造方法的用途是，允许服务器在绑定到特定端口之前，先设置ServerSocket的一些选项。因为一旦服务器与特定端口绑定，有些选项就不能再改变了。


例如：先把ServerSocket的SO_REUSEADDR选项设为true，然后再把它与8000端口绑定：
ServerSocket serverSocket = new ServerSocket();
serverSocket.setReuseAddress(true); //设置ServerSocket的选项，该选项必须在服务器绑定端口之前设置才有效
serverSocket.bind(new InetSocketAddreaa(8000)); //与8000端口绑定


接受和关闭与客户的连接
ServerSocket的accept()方法从连接请求队列中取出一个客户的连接请求然后创建与客户连接的Socket对象，并将它返回。如果队列中没有连接请求，accept()方法就会一直等待，直到接收到了连接请求才返回。接下来，服务器从Socket对象中获得输入流和输出流，就能与客户交换数据。


当服务器正在进行数据的操作时，如果客户端断开了连接，那么服务器端会抛出SocketException异常：java.net.SocketException:Connection reset by peer
这只是服务器与单个客户通信出现的异常，这种异常应该被捕获，使得服务器能继续与其他客户通信。


关闭ServerSocket
ServerSocket的close()方法使服务器释放占用的端口，并且断开与所有客户的连接。当一个服务器程序运行结束时，即使没有执行ServerSocket的close()方法，操作系统也会释放这个服务器占用的端口。因此，服务器程序并不一定在结束之前执行ServerSocket的close()方法。在某些情况下，如果希望及时释放服务器的端口，以便让其他程序能占用该端口，则可以显示调用ServerSocket的close()方法。
ServerSocket的isClosed()方法判断ServerSocket是否关闭，只有执行了ServerSocket的close()方法，isClose()方法才回返回true；否则，即使ServerSocket还没有和特定端口绑定，isClosed()方法也会返回false。


ServerSocket的isBound()方法判断ServerSocket是否已经与一个端口绑定，只要ServerSocket已经与一个端口绑定，即使它已经关闭，isBound()也会返回true。
如果需要确定一个ServerSocket已经与特定端口绑定，并且还没有被关闭，则可以采用以下方式：
boolean isOpen = serverSocket.isBound && !serverSocket.isClosed();


获取ServerSocket的信息
ServerSocket的以下两个get方法可以分别获得服务器绑定的IP地址，以及绑定的端口：
public InetAddress getInetAddress();
public int getLocalPort();


在构造ServerSocket时，如果把端口设为0，那么将有操作系统为服务器分配一个端口（称为匿名端口），程序只要调用getLocalPort()方法就能获知这个端口号。
多数服务器会监听固定的端口，这样才便于客户程序访问服务器。匿名端口一般适用于服务器与客户之间的临时通信，通信结束，就断开连接，并且ServerSocket占用的临时端口也被释放。FTP（文件传输）协议就是用了匿名端口。


ServerSocket选项：
SO_TIMEOUT：表示等待客户连接的超时时间。
SO_REUSEADDR：表示是否允许重用服务器所绑定的地址。
SO_RCVBUF：表示接受数据的缓冲区的大小。


SO_TIMEOUT选项
设置该选项：public void setSoTimeout(int timeout) throws SocketException
读取该选项：public int getSoTimeout() throws IOException
SO_TIMEOUT表示ServerSocket的accept()方法等待客户连接的超时时间，以毫秒为单位。如果SO_TIMEOUE的值为0，表示永远不会超时，这是SO_TIMEOUT的默认值。
当服务器执行ServerSocket的accept()方法时，如果连接请求队列为空，服务器就会一直等待，直到接收到了客户连接才从accept()方法返回。如果设定了超时时间，那么服务器等待的时间超过了超时时间，就会抛出SocketTimeOutException，它是InterruptedException的子类。
ServerSocket serverSocket = new ServerSocket(8000);
serverSocket.setSoTimeOut(6000);//等待客户连接的时间不超过6秒
Socket socket = serverSocket.accept();
socket.close();
System.out.println("服务器关闭");
过6秒后，程序会从serverSocket.accept()方法中抛出SocketTimeOutException


SO_REUSEADDR选项
设置该选项：public void setResuseAddress(boolean on) throws SocketExceprion
读取该选项：public boolean getReuseAddress() throws SocketException
这个选项与Socket的SO_REUSEADDR选项相同，用于决定如果网络上仍然有数据向旧的ServerSocket传输数据，是否允许新的ServerSocket绑定到与旧的ServerSocket同样的端口上。SO_REUSEADDR选项的默认值与操作系统有关，在某些操作系统中，运行重用端口，而在某些操作系统中不允许重用端口。
当ServerSocket关闭时，如果网络上还有发送到这个ServerSocket的数据，这个ServerSocket不会立刻释放本地端口，而是会等待一段时间，确保接收到了网络上发送过来的延迟数据，然后在释放端口。
许多服务器程序都是用固定的端口，当服务器程序关闭后，有可能它的端口还会被占用一段时间，如果此时立刻在同一个主机上重启服务器程序，由于端口已经被占用，使得服务器程序无法绑定到该端口，服务器启动失败，并抛出BindException：Exception in thread "main" java.net.BindException:Address already in use:JVM_Bind为了确保一个进程关闭了ServerSocket后，机试ServerSocket的setReuseAddress(true)方法:
if(!serverSocket.getReuseAddress())
serverSocket.setReuseAddress(true);
值得注意的是，serverSocket.setReuseAddress(true)方法必须在ServerSocket还没有绑定到一个本地端口之前调用，否则执行serverSocket.setReuseAddress(true)方法无效。此外，两个共用同一个端口的进程必须都调用serverSocket.setReyseAddress(ture)方法，才能使得一个进程关闭ServerSocket后，另一个进程的ServerSocket还能后立刻重用相同端口。


SO_RCFUF选项
设置该选项:public void setReceiveBufferSize(int size) throws SocketException
读取该选项：public int getReceiveBufferSize() throws SocketException
SO_RCFUF表示服务器端的用于接收数据的缓冲区的大小，以字节为单位。一般说来，传输大的连续的数据块（基于HTTP或FTP协议的数据传输）可以使用较大的缓冲区，这可以减少传输数据的次数，从而提高传输数据的效率。而对于交互式的通信（Telnet和网络游戏），则应该采用小的缓冲区，确保能及时把小批量的数据发送给对方。
SO_RCFUF的默认值与操作系统有关。


设定连接时间、延迟和带宽的相对重要性
public viod setPerformancePreferences(int connectionTime, int latency, int bandwidth)
该方法的作用与Socket的setPerformancePreferences()方法的作用相同，用于设定连接时间、延迟和带宽的相对重要性
参数int connectionTime表示短连接时间的相对重要性的
参数int latency表示最小延迟的相对重要性的
参数int bandwidth表示高带宽的相对重要性的
如果connectionTime = 2 latency = 1 bandWidth = 3就表示高带宽最重要，其次是最少连接时间，最后是最小延迟
 
创建多线程的服务器
EchoServer
while(true)
{
Socket socket = null;
try{
socket = serverSocket.accept();
.....
}catch(IOException e){
e.printStackTrace();
}finally{
try{
if(socket != null)
socket.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
假如同时有多个客户请求连接，这些客户就必须排队等候EchoServer的相应。EchoServer无法同时与多个客户通信。


许多实际应用要求服务器具有同时为多个客户提供服务的能力。HTTP服务器就是最明显的例子。任何时刻，HTTP服务器都可能接收到大量的客户请求，每个客户都希望能快速得到HTTP服务器的响应。如果长时间让客户等待，会使网站失去信誉，从而降低访问量。
可以用并发性能来衡量一个服务器同时相应多个客户的能力。一个具有好的并发性能的服务器必须符合两个条件：
(1)能同时接收并处理多个客户连接。
(2)对于每个金额户，都会迅速给予响应。
服务器同时处理的客户连接数目越多，并且对每个客户做出响应的速度越快，就表明并发性能越高。
用多个线程来同时为多个客户提供服务，这是提高服务器的并发性能的最常用的手段。


为每个客户分配一个工作线程
服务器的主线程负责接收客户的连接，每次接收到一个客户连接，就会创建一个工作线程，由它负责与客户的通信
public void service()
{
while(true)
{
Socket scoket = null;
try{
socket = serverSocket.accpet();
Thead workThread = new Thread(new Handler(socket));
workThread.start();
}catch(IOException e){
e.printStackTrace();
}
}
}


创建一个线程池，由其中的工作线程为客户服务。
对每个客户都分配一个新的工作线程。当工作线程与客户通信结束，这个线程就被销毁。
这种实现方式有以下不足之处：
(1)服务器创建和销毁工作线程的开销（包括所花费的时间和系统资源）很大。如果服务器需要与许多客户通信，并且与每个客户的通行时间都很短，那么有可能服务器为客户创建新线程的开销比实际与客户通信的开销还要大。
(2)除了创建和销毁线程的开销之外，活动的线程也消耗系统资源。每个线程本身都会占用一定的内存（每个线程需要大约1M内存），如果同时有大量客户端连接服务器，就必须创建大量工作线程。它们消耗了大量内存，可能会导致系统的内存空间不足。
(3)如果线程数目固定，并且每个线程都有很长的生命周期，那么线程切换也是相对固定的。不同操作系统有不同的切换周期，一般在20ms左右，这里所说的线程切换是指在Java虚拟机，以及底层操作系统的调度下，因为一个线程被销毁后，必然要把CPU转让给另一个已经就绪的线程，是该线程获得运行机会。在这种情况下，线程之间的切换不在云鬟系统的固定切换周期，切换线程的开销甚至比创建及销毁线程的开销还大。


线程池为线程生命周期开销问题和系统资源不足问题提供解决方案。线程池中预先创建了一些工作线程，他们不断从工作队列中取出任务，然后执行该任务。当工作线程执行完一个任务时，就会继续执行工作队列中的下一个任务。
线程池具有一下优点：
(1)减少了创建和销毁线程的次数，每个工作线程都可以一直被重用，能执行多个任务。
(2)可以根据系统的承载能力，方便调整线程池中线程的数目，放置因为消耗过量系统资源而导致系统崩溃。


import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;


public class ThreadPool extends ThreadGroup
{
private boolean isClosed = false; //线程池是否关闭
private LinkedList<Runnable> workQueue; //表示工作队列
private static int threadPoolID //表示线程池ID
private int threadID; //表示工作线程ID

public ThreadPool(int poolSize)
{
super("ThreadPool " + (threadPoolID++));
setDaemon(true); //设置为后台线程
workQueue = new LinkedList<Runnable>();
for(int i = 0; i < poolSize; i++)
new WorkThread().start(); //创建并启动动作线程
}
}


/**
 * 向工作队列中加入一个新任务，由工作线程去执行该任务
 **/
 public synchronized void execute(Runnable task)
 {
if(isClosed) //线程池被关闭则抛出lllegalStateException异常
{
throw new lllegalStateException();
}

if(task != null)
{
workQueue.add(task);
notify(); //唤醒正在getTask()方法中等待任务的工作线程
}
 }
 
 /**
  * 从工作队列中取出一个任务，工作线程会调用此方法
  **/
protected synchronized Runnable getTask() throws
InterruptedException
{
if(workQueue.size() == 0)
{
if(isClosed)
{
  System.out.println(Thread.currentThread().getName() + "等待接受任务");
}

while(workQueue.size() == 0)
{
if(isClosed)
return null;
wait(); //如果工作队列中没有任务，就等待任务
}
if(workQueue.size() != 0)
{
Customer c = (Customer)workQueue.set(0);
System.err.println(Thread.currentThread().getName() + "执行" + c.getName());
}
return workQueue.removeFirst();
}
}


/* 关闭线程池*/
public synchronozed void close()
{
if(!isClosed)
{
isClosed = true;
workQueue.clear(); //清空工作队列
interrupt(); //中断所有的工作线程，该方法继承自ThreadGroup类
}
}


/* 等待工作线程把所有任务执行完 */
public void join()
{
synchronized (this)
{
isClosed = true;
notifyAll(); //唤醒还在getTask()方法中等待任务的工作线程
}
Thread[] threads = new Thread[activeCount()];
//enumerate()方法继承自ThreadGroup类，获得线程组中当前所有活着的工作线程
int count = enumerate(thrads);
for(int i = 0; i < count; i++)
{
try
{
threads[i].join(); //等待工作线程运行结束
}catch(InterruptedException ex){
ex.printStackTrace();
}
}
}


private class WorkThread extends Thread
{
public WorkThread()
{
//加入到当前ThreadPool线程组中
super(ThreadPool.this, "WorkThread " + (threadID++));
}

public void run()
{
while(!idInterrupted()) //isInterrupted()方法继承自Thread类，判断线程是否被中断
{
Runnable task = null;
try{
task = getTask();
}catch(InterruptedException ex){

}
if(task = null)
return;
try{//运行任务，异常在catch代码块中捕获
task.run();
}catch(Throwable t)
{
t.printStackTrace();
}
}

}
}


public static void main(String[] args) throws InterruptedException
{
main1();
}


private static void main1() throws InterriptedException
{
ThradPool pool = new ThreadPool(3);
Customer c1 = new Customer("1111111111");
Customer c2 = new Customer("2222222222");
Customer c3 = new Customer("3333333333");
Customer c4 = new Customer("4444444444");
Customer c5 = new Customer("5555555555");

Thread.sleep(2000);
System.out.println("===========");
pool.execute(c1);
pool.execute(c2);
pool.execute(c3);
pool.execute(c4);
pool.execute(c5);
Thread.sleep(2000);
System.out.println("当前活动的线程数：" + pool.activeCount);
pool.close();
}


static class Customer implements Runnable
{
private String name;
public Customer()
{
}

public Customer(String name)
{
this.name = name;
}

public void run()
{
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try{
System.out.println("start: " + sdf.format(new Date()));
Thread.slepp(5000);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println("end: " + sdf.format(new Date()));
}
public String getName()
{
return name;
}
}


利用JDK的Java类库中线程的线程库，由它的工作线程来为客户服务
java.util.concurrent包提供了现成的线程池的实现
Executor接口表示线程池，它的execute(Runnable task)方法用来执行Runnable类型的任务,Executor的子接口ExecutorService中声明了管理线程池的一些方法，比如用来关闭线程池的shutdown()方法等。Executor类中包含一些静态方法，它们负责生成各种类型的线程池ExecutorService实例。
newCachedThreadPool()在有任务时才创建线程池，空闲线程保留60秒
newFixedThreadPool(int nThreads)创建含nThreads线程的线程池，空闲线程会一直保留
newSingleThreadExecutor()创建一个只含有单个线程的线程池
newScheduledThreadPool(int corePoolSize)线程池按时间计划来执行任务，允许用户设置计划任务的时间，sorePoolSize设置线程池中线程的最小数目，当任务较多时，线程池可能会创建更多的线程来执行任务。




使用线程池的注意事项：
虽然线程池能大大提高服务器的并发性能，但使用它会存在一定风险。与所有多线程应用程序一样，用线程池勾践的应用程序容易产生各种并发问题，如对共享资源的竞争和死锁。此外，如果线程池本身的实现不健壮，或者没有合理的使用线程池，还容易导致与线程池有关的死锁、系统资源不足和线程泄露等问题。


(1)死锁
任何多线程应用都有死锁风险。造成死锁的最简单的情形是，线程A持有对象X的锁，并且在等待对象Y的锁，而线程B持有对象Y的锁，并且在等待对象X的锁。线程A与线程B都不释放自己持有的锁，并且等待对方的锁，这就导致两个线程永远等待下去，死锁就这样产生了。虽然，任何多线程程序都有死锁的风险，但线程池还会导致另外一种死锁。在这种情形下，假定线程池中的所有工作线程都在执行各自任务时被阻塞了，他们都在等待某个任务A的执行结果。而任务A依然在工作队列中，由于没有空闲线程，使得任务A一直不能被执行。这使得线程池中的所有工作线程都永远阻塞下去，死锁就这样产生了。
(2)系统资源不足
如果线程池中的线程数目非常多，这些线程会消耗包括内存和其他系统资源在内的大量资源，从而严重影响系统性能。
(3)并发错误
线程池的工作队列依靠wait()和notify()来使工作线程及时取得任务，但这两个方法都难于使用。如果编码不正确，可能会丢失通知，导致工作线程一直保持空闲状态，无视工作队列中需要处理的任务。因此使用这些方法时，必须格外的小心，即便是专家也可能在这方面出错。最好使用现有的、比较成熟的线程池。
例如，直接使用java.util.concurrent包中的线程池类。
(4)线程泄漏
使用线程池的一个严重风险就是线程泄漏。对于工作线程数目固定的线程池，如果工作线程在执行任务时抛出RuntimeException或Error，并且这些异常或错误没有被捕获，那么这个工作线程就会异常终止，使得线程池永久失去了一个工作线程，如果所有的工作线程都异常终止，线程池就最终变为空，没有任何可用的工作线程来处理任务。
导致线程泄漏的另一种情形是，工作线程在执行一个任务时被阻塞，如等待用户的输入数据，但是由于用户一直不输入数据导致这个工作线程一直被阻塞。这样的工作线程名存实亡，它实际上不执行任何任务了。假如线程池中所有的工作线程都处于这样的阻塞状态，那么线程池就无法处理新加入的任务了。
(5)任务过载
当工作队列中有大量排队等候执行的任务时，这些人物本身可能会消耗太多的系统资源，而引起系统资源缺乏。


综上所述，线程池可能会带来种种的风险，为了尽可能的避免它们，使用线程池时需要遵循以下原则：
(1)如果任务A在执行过程中需要同步等待任务B的执行结果，那么任务A不适合加入到线程池的工作队列中。如果把像任务A一样的需要等待其他任务执行结果的任务加入到工作队列中，可能会导致线程池的死锁。
(2)如果执行某个任务时可能会阻塞，并且是长时间的阻塞，则应该设定超时时间，避免工作线程永久的阻塞下去而导致线程泄漏。在服务器程序中，当线程等待客户连接，或者等待客户发送的数据时，都可能会阻塞。可以通过一下方式设定超市时间：
调用ServerSocket的setSoTimeOut(int timeout)方法，设定等待客户连接的超时时间。
对于每个与客户连接的Socket，调用该Socket的setSoTimeOut(int timeout)方法，设定等待客户发送数据的超时时间。
(3)了解任务的特点，分析任务是执行经常会阻塞的I/O操作，还是执行一直不回阻塞的运算操作。前者时断时续地占用CPU，而后者对CPU具有更高的利用率。预计完成任务大概需要多长时间？是短时间任务还是长时间任务？
(4)调整线程池的大小。线程池的最佳大小主要取决于系统的可用CPU的数目，以及工作队列中任务的特点，假如在一个具有N个CPU的系统上只有一个工作队列，并且其中全部是运算性质（不会阻塞）的任务，那么当线程池具有N或N+1个工作线程时，一般会获得最大的CPU利用率。
(5)避免任务过载。服务器应根据系统的承载能力，限制客户并发连接的数目。当客户并发连接的数目超过了限制值，服务器可以拒绝连接请求，并友好地告知客户：服务器正忙，请稍后再试。


关闭服务器
强行终止服务器程序会导致服务器中正在执行的任务被忽然中断，服务器除了在8000端口监听普通客户程序EchoClient的连接外，还会在8001端口监听管理程序AdminCLient的连接。当服务器在8001端口接收到了AdminClient发送的"shutdown"命令时，EchoServer就会开始关闭服务器，它不会再接受任何心得EchoClient进程的连接请求，对于哪些已经接收但是还没有处理的客户连接，则会丢弃与该客户的通信任务，而不会把通信任务加入到线程池的工作队列中。另外，EchoServer会等到线程池把当前工作队列中的所有任务执行完，才结束程序。