ServerSocket

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的accept()方法从队列中取出连接请求，使队列腾出空位时，队列才能继续加入新的连接请求。

对于客户进程，如果它发出的连接请求被加入到服务器的队列中，就意味着客户与服务器的连接建立成功，客户进程从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 InetSocketAddress(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()方法，isClosed()方法才返回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_TIMEOUT的值为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()方法中抛出Socket- TimeoutException

SO_REUSEADDR选项
设置该选项：public void setResuseAddress(boolean on) throws SocketException
读取该选项：public boolean getResuseAddress() 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的setResuse- Address(true)方法：
if(!serverSocket.getResuseAddress())serverSocket.setResuseAddress(true);
值得注意的是，serverSocket.setResuseAddress(true)方法必须在ServerSocket还没有绑定到一个本地端口之前调用，否则执行serverSocket.setResuseAddress(true)方法无效。此外，两个共用同一个端口的进程必须都调用 serverSocket.setResuseAddress(true)方法，才能使得一个进程关闭ServerSocket后，另一个进程的 ServerSocket还能够立刻重用相同端口

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

设定连接时间、延迟和带宽的相对重要性
public void 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服务器的响应。如果长时间让客户等待，会使网站失去信誉，从而降低访问量。
可以用并发性能来衡量一个服务器同时响应多个客户的能力。一个具有好的并发性能的服务器，必须符合两个条件：
能同时接收并处理多个客户连接；
对于每个客户，都会迅速给予响应。
服务器同时处理的客户连接数目越多，并且对每个客户作出响应的速度越快，就表明并发性能越高。
用多个线程来同时为多个客户提供服务，这是提高服务器的并发性能的最常用的手段。


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


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

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

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) { // 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) { // 线程池被关则抛出IllegalStateException异常
throw new IllegalStateException();
}
if (task != null) {
workQueue.add(task);
notify(); // 唤醒正在getTask()方法中等待任务的工作线程
}
}

/**
* 从工作队列中取出一个任务，工作线程会调用此方法
*/
protected synchronized Runnable getTask() throws InterruptedException {
if(workQueue.size()==0){
System.out.println(Thread.currentThread().getName()+" 等待接受任务");
}
while (workQueue.size() == 0) {
if (isClosed)
return null;
wait(); // 如果工作队列中没有任务，就等待任务
}
if(workQueue.size()!=0){
Customer c = (Customer) workQueue.get(0);
System.err.println(
Thread.currentThread().getName()+" 执行"+c.getName());
}
return workQueue.removeFirst();
}

/** 关闭线程池 */
public synchronized 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(threads);
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 (!isInterrupted()) { // 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 InterruptedException {
ThreadPool pool = new ThreadPool(3);
Customer c1 = new Customer("1111111111111");
Customer c2 = new Customer("2222222222222");
Customer c3 = new Customer("3333333333333");
Customer c4 = new Customer("4444444444444");
Customer c5 = new Customer("5555555555555");
Thread.sleep(2000);
System.out.println("============================");
pool.execute(c1);
pool.execute(c2);
pool.execute(c3);
pool.execute(c4);
pool.execute(c5);
Thread.sleep(20000);
System.out.println("当前活动的线程数："+pool.activeCount());
pool.close();
}
static class Customer implements Runnable{
private String name;
public Customer(){ }
public Customer(String name){
this.name = name;
}
@Override
public void run() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
System.out.println("start:"+sdf.format(new Date()));
Thread.sleep(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()方法等。Executors类中包含一些静态方法，它们负责生成各种类型的线程池ExecutorService实例
newCachedThreadPool() 在有任务时才创建线程池，空闲线程保留60秒
newFixedThreadPool(int nThreads) 创建含nThreads线程的线程池，空闲线程会一直保留
newSingleThreadExecutor() 创建一个只含有单个线程的线程池
newScheduledThreadPool(int corePoolSize) 线程池按时间计划来执行任务，允许用户设置计划任务的时间，corePoolSize设置线程池中线程的最小数目，当任务较多时，线程池可能会创建更多的工作线程来执行任务

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

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会等到线程池把当前工作队列中的所有任务执行完，才结束程序。