java socket编程中一些方法参数的意义
3.1? 构造ServerSocket
ServerSocket的构造方法有以下几种重载形式：
◆ServerSocket()throws IOException
ServerSocket serverSocket=new ServerSocket(80);
如果运行时无法绑定到80端口，以上代码会抛出IOException，更确切地说，是抛出BindException，它是IOException的子类。BindException一般是由以下原因造成的：
◆端口已经被其他服务器进程占用；
◆在某些操作系统中，如果没有以超级用户的身份来运行服务器程序，那么操作系统不允许服务器绑定到1~1023之间的端口。
如果把参数port设为0，表示由操作系统来为服务器分配一个任意可用的端口。由操作系统分配的端口也称为匿名端口。对于多数服务器，会使用明确的端口，而不会使用匿名端口，因为客户程序需要事先知道服务器的端口，才能方便地访问服务器。在某些场合，匿名端口有着特殊的用途，本章3.4节会对此作介绍。
3.1.2? 设定客户连接请求队列的长度
当服务器进程运行时，可能会同时监听到多个客户的连接请求。例如，每当一个客户进程执行以下代码：
Socket socket=new Socket(www.javathinker.org,80);
就意味着在远程www.javathinker.org主机的80端口上，监听到了一个客户的连接请求。管理客户连接请求的任务是由操作系统来完成的。操作系统把这些连接请求存储在一个先进先出的队列中。许多操作系统限定了队列的最大长度，一般为50。当队列中的连接请求达到了队列的最大容量时，服务器进程所在的主机会拒绝新的连接请求。只有当服务器进程通过ServerSocket的accept()方法从队列中取出连接请求，使队列腾出空位时，队列才能继续加入新的连接请求。
对于客户进程，如果它发出的连接请求被加入到服务器的队列中，就意味着客户与服务器的连接建立成功，客户进程从Socket构造方法中正常返回。如果客户进程发出的连接请求被服务器拒绝，Socket构造方法就会抛出ConnectionException。
ServerSocket构造方法的backlog参数用来显式设置连接请求队列的长度，它将覆盖操作系统限定的队列的最大长度。值得注意的是，在以下几种情况中，仍然会采用操作系统限定的队列的最大长度：
◆backlog参数的值大于操作系统限定的队列的最大长度；
◆backlog参数的值小于或等于0；
◆在ServerSocket构造方法中没有设置backlog参数。
以下例程3-1的Client.java和例程3-2的Server.java用来演示服务器的连接请求队列的特性。
例程3-1? Client.java
import java.net.*;
public class Client {
? public static void main(String args[])throws Exception{
??? final int length=100;
??? String host="localhost";
??? int port=8000;
??? Socket[] sockets=new Socket[length];
??? for(int i=0;i<LENGTH;I++){&NBSP; 试图建立100次连接<br="" ???="">????? sockets[i]=new Socket(host, port);
????? System.out.println("第"+(i+1)+"次连接成功");
??? }
??? Thread.sleep(3000);
??? for(int i=0;i<LENGTH;I++){
????? sockets[i].close();? ????//断开连接
??? }
? }
}
#p#
例程3-2? Server.java
import java.io.*;
import java.net.*;
public class Server {
? private int port=8000;
? private ServerSocket serverSocket;
? public Server() throws IOException {
??? serverSocket = new ServerSocket(port,3);? ??//连接请求队列的长度为3
??? System.out.println("服务器启动");
? }
? public void service() {
??? while (true) {
????? Socket socket=null;
????? try {
??????? socket = serverSocket.accept();? ???//从连接请求队列中取出一个
连接
??????? System.out.println("New connection accepted " +
??????? socket.getInetAddress() + ":" +socket.getPort());
????? }catch (IOException e) {
???????? e.printStackTrace();
????? }finally {
???????? try{
?????????? if(socket!=null)socket.close();
???????? }catch (IOException e) {e.printStackTrace();}
????? }
??? }
? }
? public static void main(String args[])throws Exception {
??? Server server=new Server();
??? Thread.sleep(60000*10);? ????//睡眠10分钟
??? //server.service();
? }
}
Client试图与Server进行100次连接。在Server类中，把连接请求队列的长度设为3。这意味着当队列中有了3个连接请求时，如果Client再请求连接，就会被Server拒绝。下面按照以下步骤运行Server和Client程序。
（1）把Server类的main()方法中的“server.service();”这行程序代码注释掉。这使得服务器与8000端口绑定后，永远不会执行serverSocket.accept()方法。这意味着队列中的连接请求永远不会被取出。先运行Server程序，然后再运行Client程序，Client程序的打印结果如下：
第1次连接成功
第2次连接成功
第3次连接成功
Exception in thread "main" java.net.ConnectException: Connection refused: connect
??????? at java.net.PlainSocketImpl.socketConnect(Native Method)
??????? at java.net.PlainSocketImpl.doConnect(Unknown Source)
??????? at java.net.PlainSocketImpl.connectToAddress(Unknown Source)
??????? at java.net.PlainSocketImpl.connect(Unknown Source)
??????? at java.net.SocksSocketImpl.connect(Unknown Source)
??????? at java.net.Socket.connect(Unknown Source)
??????? at java.net.Socket.connect(Unknown Source)
??????? at java.net.Socket.(Unknown Source)
??????? at java.net.Socket.(Unknown Source)
??????? at Client.main(Client.java:10)
从以上打印结果可以看出，Client与Server在成功地建立了3个连接后，就无法再创建其余的连接了，因为服务器的队列已经满了。
（2）把Server类的main()方法按如下方式修改：
public static void main(String args[])throws Exception {
??? Server server=new Server();
??? //Thread.sleep(60000*10);? //睡眠10分钟
??? server.service();
? }
作了以上修改，服务器与8 000端口绑定后，就会在一个while循环中不断执行serverSocket.accept()方法，该方法从队列中取出连接请求，使得队列能及时腾出空位，以容纳新的连接请求。先运行Server程序，然后再运行Client程序，Client程序的打印结果如下：
第1次连接成功
第2次连接成功
第3次连接成功
…
第100次连接成功
从以上打印结果可以看出，此时Client能顺利与Server建立100次连接。
3.1.3? 设定绑定的IP地址
如果主机只有一个IP地址，那么默认情况下，服务器程序就与该IP地址绑定。ServerSocket的第4个构造方法ServerSocket(int port, int backlog, InetAddress bindAddr)有一个bindAddr参数，它显式指定服务器要绑定的IP地址，该构造方法适用于具有多个IP地址的主机。假定一个主机有两个网卡，一个网卡用于连接到Internet， IP地址为222.67.5.94，还有一个网卡用于连接到本地局域网，IP地址为192.168.3.4。如果服务器仅仅被本地局域网中的客户访问，那么可以按如下方式创建ServerSocket：
ServerSocket serverSocket=new ServerSocket(8000,10,InetAddress.getByName ("192.168.3.4"));
3.1.4? 默认构造方法的作用
ServerSocket有一个不带参数的默认构造方法。通过该方法创建的ServerSocket不与任何端口绑定，接下来还需要通过bind()方法与特定端口绑定。
这个默认构造方法的用途是，允许服务器在绑定到特定端口之前，先设置ServerSocket的一些选项。因为一旦服务器与特定端口绑定，有些选项就不能再改变了。
在以下代码中，先把ServerSocket的SO_REUSEADDR选项设为true，然后再把它与8000端口绑定：
ServerSocket serverSocket=new ServerSocket();
serverSocket.setReuseAddress(true);? ????//设置ServerSocket的选项
serverSocket.bind(new InetSocketAddress(8000)); ??//与8000端口绑定
如果把以上程序代码改为：
ServerSocket serverSocket=new ServerSocket(8000);
serverSocket.setReuseAddress(true);? ????//设置ServerSocket的选项
那么serverSocket.setReuseAddress(true)方法就不起任何作用了，因为SO_ REUSEADDR选项必须在服务器绑定端口之前设置才有效。
#p#
3.2? 接收和关闭与客户的连接
ServerSocket的accept()方法从连接请求队列中取出一个客户的连接请求，然后创建与客户连接的Socket对象，并将它返回。如果队列中没有连接请求，accept()方法就会一直等待，直到接收到了连接请求才返回。
接下来，服务器从Socket对象中获得输入流和输出流，就能与客户交换数据。当服务器正在进行发送数据的操作时，如果客户端断开了连接，那么服务器端会抛出一个IOException的子类SocketException异常：
java.net.SocketException: Connection reset by peer
这只是服务器与单个客户通信中出现的异常，这种异常应该被捕获，使得服务器能继续与其他客户通信。
以下程序显示了单线程服务器采用的通信流程：
public void service() {
? while (true) {
??? Socket socket=null;
??? try {
????? socket = serverSocket.accept();? ??//从连接请求队列中取出一个连接
????? System.out.println("New connection accepted " +
????? socket.getInetAddress() + ":" +socket.getPort());
????? //接收和发送数据
????? …
??? }catch (IOException e) {
????? //这只是与单个客户通信时遇到的异常，可能是由于客户端过早断开连接引起的
????? //这种异常不应该中断整个while循环
?????? e.printStackTrace();
??? }finally {
?????? try{
???????? if(socket!=null)socket.close();? ??//与一个客户通信结束后，要关闭
Socket
?????? }catch (IOException e) {e.printStackTrace();}
??? }
? }
}
与单个客户通信的代码放在一个try代码块中，如果遇到异常，该异常被catch代码块捕获。try代码块后面还有一个finally代码块，它保证不管与客户通信正常结束还是异常结束，最后都会关闭Socket，断开与这个客户的连接。
3.3? 关闭ServerSocket
ServerSocket的close()方法使服务器释放占用的端口，并且断开与所有客户的连接。当一个服务器程序运行结束时，即使没有执行ServerSocket的close()方法，操作系统也会释放这个服务器占用的端口。因此，服务器程序并不一定要在结束之前执行ServerSocket的close()方法。
在某些情况下，如果希望及时释放服务器的端口，以便让其他程序能占用该端口，则可以显式调用ServerSocket的close()方法。例如，以下代码用于扫描1~65535之间的端口号。如果ServerSocket成功创建，意味着该端口未被其他服务器进程绑定，否者说明该端口已经被其他进程占用：
for(int port=1;port<=65535;port++){
? try{
ServerSocket serverSocket=new ServerSocket(port);
serverSocket.close();? ?//及时关闭ServerSocket
? }catch(IOException e){
??? System.out.println("端口"+port+" 已经被其他服务器进程占用");
}
}
以上程序代码创建了一个ServerSocket对象后，就马上关闭它，以便及时释放它占用的端口，从而避免程序临时占用系统的大多数端口。
ServerSocket的isClosed()方法判断ServerSocket是否关闭，只有执行了ServerSocket的close()方法，isClosed()方法才返回true；否则，即使ServerSocket还没有和特定端口绑定，isClosed()方法也会返回false。
ServerSocket的isBound()方法判断ServerSocket是否已经与一个端口绑定，只要ServerSocket已经与一个端口绑定，即使它已经被关闭，isBound()方法也会返回true。
如果需要确定一个ServerSocket已经与特定端口绑定，并且还没有被关闭，则可以采用以下方式：
boolean isOpen=serverSocket.isBound() && !serverSocket.isClosed();
3.4? 获取ServerSocket的信息
ServerSocket的以下两个get方法可分别获得服务器绑定的IP地址，以及绑定的端口：
◆public InetAddress getInetAddress()
◆public int getLocalPort()
前面已经讲到，在构造ServerSocket时，如果把端口设为0，那么将由操作系统为服务器分配一个端口（称为匿名端口），程序只要调用getLocalPort()方法就能获知这个端口号。如例程3-3所示的RandomPort创建了一个ServerSocket，它使用的就是匿名端口。
#p#
例程3-3? RandomPort.java
import java.io.*;
import java.net.*;
public class RandomPort{
? public static void main(String args[])throws IOException{
??? ServerSocket serverSocket=new ServerSocket(0);
??? System.out.println("监听的端口为:"+serverSocket.getLocalPort());
? }
}
多次运行RandomPort程序，可能会得到如下运行结果：
C:\chapter03\classes>java RandomPort
监听的端口为:3000
C:\chapter03\classes>java RandomPort
监听的端口为:3004
C:\chapter03\classes>java RandomPort
监听的端口为:3005
多数服务器会监听固定的端口，这样才便于客户程序访问服务器。匿名端口一般适用于服务器与客户之间的临时通信，通信结束，就断开连接，并且ServerSocket占用的临时端口也被释放。
FTP（文件传输）协议就使用了匿名端口。如图3-1所示，FTP协议用于在本地文件系统与远程文件系统之间传送文件。
?
图3-1? FTP协议用于在本地文件系统与远程文件系统之间传送文件
FTP使用两个并行的TCP连接：一个是控制连接，一个是数据连接。控制连接用于在客户和服务器之间发送控制信息，如用户名和口令、改变远程目录的命令或上传和下载文件的命令。数据连接用于传送文件。TCP服务器在21端口上监听控制连接，如果有客户要求上传或下载文件，就另外建立一个数据连接，通过它来传送文件。数据连接的建立有两种方式。
（1）如图3-2所示，TCP服务器在20端口上监听数据连接，TCP客户主动请求建立与该端口的连接。
?
图3-2? TCP服务器在20端口上监听数据连接
（2）如图3-3所示，首先由TCP客户创建一个监听匿名端口的ServerSocket，再把这个ServerSocket监听的端口号（调用ServerSocket的getLocalPort()方法就能得到端口号）发送给TCP服务器，然后由TCP服务器主动请求建立与客户端的连接。
?
图3-3? TCP客户在匿名端口上监听数据连接
以上第二种方式就使用了匿名端口，并且是在客户端使用的，用于和服务器建立临时的数据连接。在实际应用中，在服务器端也可以使用匿名端口。
3.5? ServerSocket选项
ServerSocket有以下3个选项。
◆SO_TIMEOUT：表示等待客户连接的超时时间。
◆SO_REUSEADDR：表示是否允许重用服务器所绑定的地址。
◆SO_RCVBUF：表示接收数据的缓冲区的大小。
3.5.1? 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的子类。
如例程3-4所示的TimeoutTester把超时时间设为6秒钟。
#p#
例程3-4? TimeoutTester.java
import java.io.*;
import java.net.*;
public class TimeoutTester{
? public static void main(String args[])throws IOException{
??? ServerSocket serverSocket=new ServerSocket(8000);
??? serverSocket.setSoTimeout(6000); //等待客户连接的时间不超过6秒
??? Socket socket=serverSocket.accept();
??? socket.close();
??? System.out.println("服务器关闭");
? }
}
运行以上程序，过6秒钟后，程序会从serverSocket.accept()方法中抛出Socket- TimeoutException：
C:\chapter03\classes>java TimeoutTester
Exception in thread "main" java.net.SocketTimeoutException: Accept timed out
??????? at java.net.PlainSocketImpl.socketAccept(Native Method)
??????? at java.net.PlainSocketImpl.accept(Unknown Source)
??????? at java.net.ServerSocket.implAccept(Unknown Source)
??????? at java.net.ServerSocket.accept(Unknown Source)
??????? at TimeoutTester.main(TimeoutTester.java:8)
如果把程序中的“serverSocket.setSoTimeout(6000)”注释掉，那么serverSocket. accept()方法永远不会超时，它会一直等待下去，直到接收到了客户的连接，才会从accept()方法返回。
Tips：服务器执行serverSocket.accept()方法时，等待客户连接的过程也称为阻塞。本书第4章的4.1节（线程阻塞的概念）详细介绍了阻塞的概念。
3.5.2? 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还能够立刻重用相同端口。
3.5.3? SO_RCVBUF选项
◆设置该选项：public void setReceiveBufferSize(int size) throws SocketException
◆读取该选项：public int getReceiveBufferSize() throws SocketException
SO_RCVBUF表示服务器端的用于接收数据的缓冲区的大小，以字节为单位。一般说来，传输大的连续的数据块（基于HTTP或FTP协议的数据传输）可以使用较大的缓冲区，这可以减少传输数据的次数，从而提高传输数据的效率。而对于交互式的通信（Telnet和网络游戏），则应该采用小的缓冲区，确保能及时把小批量的数据发送给对方。
SO_RCVBUF的默认值与操作系统有关。例如，在Windows 2000中运行以下代码时，显示SO_RCVBUF的默认值为8192：
ServerSocket serverSocket=new ServerSocket(8000);
System.out.println(serverSocket.getReceiveBufferSize());?? ?//打印8192
无论在ServerSocket绑定到特定端口之前或之后，调用setReceiveBufferSize()方法都有效。例外情况下是如果要设置大于64K的缓冲区，则必须在ServerSocket绑定到特定端口之前进行设置才有效。例如，以下代码把缓冲区设为128K：
ServerSocket serverSocket=new ServerSocket();
int size=serverSocket.getReceiveBufferSize();
if(size<131072) serverSocket.setReceiveBufferSize(131072);??//把缓冲区的大小设为128K
serverSocket.bind(new InetSocketAddress(8000));? ???//与8 000端口绑定
执行serverSocket.setReceiveBufferSize()方法，相当于对所有由serverSocket.accept()方法返回的Socket设置接收数据的缓冲区的大小。
3.5.4? 设定连接时间、延迟和带宽的相对重要性
◆public void setPerformancePreferences(int connectionTime,int latency,int bandwidth)
该方法的作用与Socket的setPerformancePreferences()方法的作用相同，用于设定连接时间、延迟和带宽的相对重要性，参见本书第2章的2.5.10节（设定连接时间、延迟和带宽的相对重要性）。
?
客户端:
Socket选择可以指定Socket类发送和接受数据的方式。在JDK1.4中共有8个Socket选择可以设置。这8个选项都定义在java.net.SocketOptions接口中。定义如下：
public final static int TCP_NODELAY = 0x0001;
public final static int SO_REUSEADDR = 0x04;
public final static int SO_LINGER = 0x0080;
public final static int SO_TIMEOUT = 0x1006;
public final static int SO_SNDBUF = 0x1001;
public final static int SO_RCVBUF = 0x1002;
public final static int SO_KEEPALIVE = 0x0008;
public final static int SO_OOBINLINE = 0x1003;
有趣的是，这8个选项除了第一个没在SO前缀外，其他7个选项都以SO作为前缀。其实这个SO就是Socket Option的缩写；因此，在Java中约定所有以SO为前缀的常量都表示Socket选项；当然，也有例外，如TCP_NODELAY。在Socket类中为每一个选项提供了一对get和set方法，分别用来获得和设置这些选项。
1.TCP_NODELAY
public boolean getTcpNoDelay() throws SocketException
public void setTcpNoDelay(boolean on) throws SocketException
在默认情况下，客户端向服务器发送数据时，会根据数据包的大小决定是否立即发送。当数据包中的数据很少时，如只有1个字节，而数据包的头却有几十个字节（IP头+TCP头）时，系统会在发送之前先将较小的包合并到软大的包后，一起将数据发送出去。在发送下一个数据包时，系统会等待服务器对前一个数据包的响应，当收到服务器的响应后，再发送下一个数据包，这就是所谓的Nagle算法；在默认情况下，Nagle算法是开启的。
这种算法虽然可以有效地改善网络传输的效率，但对于网络速度比较慢，而且对实现性的要求比较高的情况下（如游戏、Telnet等），使用这种方式传输数据会使得客户端有明显的停顿现象。因此，最好的解决方案就是需要Nagle算法时就使用它，不需要时就关闭它。而使用setTcpToDelay正好可以满足这个需求。当使用setTcpNoDelay(true)将Nagle算法关闭后，客户端每发送一次数据，无论数据包的大小都会将这些数据发送出去。
2.SO_REUSEADDR
public boolean getReuseAddress() throws SocketException
public void setReuseAddress(boolean on) throws SocketException
通过这个选项，可以使多个Socket对象绑定在同一个端口上。其实这样做并没有多大意义，但当使用close方法关闭Socket连接后，Socket对象所绑定的端口并不一定马上释放；系统有时在Socket连接关闭才会再确认一下是否有因为延迟面未到达的数据包，这完全是在底层处理的，也就是说对用户是透明的；因此，在使用Socket类时完全不会感觉到。
这种处理机制对于随机绑定端口的Socket对象没有什么影响，但对于绑定在固定端口的Socket对象就可能会抛出“Address already in use: JVM_Bind”例外。因此，使用这个选项可以避免个例外的发生。
package mynet;
import java.net.*;
import java.io.*;
public class Test
{
public static void main(String[] args)
{
Socket socket1 = new Socket();
Socket socket2 = new Socket();
try
{
socket1.setReuseAddress(true);
socket1.bind(new InetSocketAddress("127.0.0.1", 88));
System.out.println("socket1.getReuseAddress():"
+ socket1.getReuseAddress());
socket2.bind(new InetSocketAddress("127.0.0.1", 88));
}
catch (Exception e)
{
System.out.println("error:" + e.getMessage());
try
{
socket2.setReuseAddress(true);
socket2.bind(new InetSocketAddress("127.0.0.1", 88));
System.out.println("socket2.getReuseAddress():"
+ socket2.getReuseAddress());
System.out.println("端口88第二次绑定成功!");
}
catch (Exception e1)
{
System.out.println(e.getMessage());
}
}
}
}
?
上面的代码的运行结果如下：
socket1.getReuseAddress():true
error:Address already in use: JVM_Bind
socket2.getReuseAddress():true
端口88第二次绑定成功!
使用SO_REUSEADDR选项时有两点需要注意：
1.必须在调用bind方法之前使用setReuseAddress方法来打开SO_REUSEADDR选项。因此，要想使用SO_REUSEADDR选项，就不能通过Socket类的构造方法来绑定端口。
2.必须将绑定同一个端口的所有的Socket对象的SO_REUSEADDR选项都打开才能起作用。如在例程4-12中，socket1和socket2都使用了setReuseAddress方法打开了各自的SO_REUSEADDR选项。
3.SO_LINGER
public int getSoLinger() throws SocketException
public void setSoLinger(boolean on, int linger) throws SocketException
这个Socket选项可以影响close方法的行为。在默认情况下，当调用close方法后，将立即返回；如果这时仍然有未被送出的数据包，那么这些数据包将被丢弃。如果将linger参数设为一个正整数n时(n的值最大是65,535)，在调用close方法后，将最多被阻塞n秒。在这n秒内，系统将尽量将未送出的数据包发送出去；如果超过了n秒，如果还有未发送的数据包，这些数据包将全部被丢弃；而close方法会立即返回。如果将linger设为0，和关闭SO_LINGER选项的作用是一样的。
如果底层的Socket实现不支持SO_LINGER都会抛出SocketException例外。当给linger参数传递负数值时，setSoLinger还会抛出一个IllegalArgumentException例外。可以通过getSoLinger方法得到延迟关闭的时间，如果返回-1，则表明SO_LINGER是关闭的。例如，下面的代码将延迟关闭的时间设为1分钟：
if(socket.getSoLinger() == -1) socket.setSoLinger(true, 60);
4.SO_TIMEOUT
public int getSoTimeout() throws SocketException
public void setSoTimeout(int timeout) throws SocketException
这个Socket选项在前面已经讨论过。可以通过这个选项来设置读取数据超时。当输入流的read方法被阻塞时，如果设置timeout（timeout的单位是毫秒），那么系统在等待了timeout毫秒后会抛出一个InterruptedIOException例外。在抛出例外后，输入流并未关闭，你可以继续通过read方法读取数据。
如果将timeout设为0，就意味着read将会无限等待下去，直到服务端程序关闭这个Socket。这也是timeout的默认值。如下面的语句将读取数据超时设为30秒：
socket1.setSoTimeout(30 * 1000);
当底层的Socket实现不支持SO_TIMEOUT选项时，这两个方法将抛出SocketException例外。不能将timeout设为负数，否则setSoTimeout方法将抛出IllegalArgumentException例外。
5.SO_SNDBUF
public int getSendBufferSize() throws SocketException
public void setSendBufferSize(int size) throws SocketException
在默认情况下，输出流的发送缓冲区是8096个字节（8K）。这个值是Java所建议的输出缓冲区的大小。如果这个默认值不能满足要求，可以用setSendBufferSize方法来重新设置缓冲区的大小。但最好不要将输出缓冲区设得太小，否则会导致传输数据过于频繁，从而降低网络传输的效率。
如果底层的Socket实现不支持SO_SENDBUF选项，这两个方法将会抛出SocketException例外。必须将size设为正整数，否则setSendBufferedSize方法将抛出IllegalArgumentException例外。
?
6.SO_RCVBUF
public int getReceiveBufferSize() throws SocketException
public void setReceiveBufferSize(int size) throws SocketException
在默认情况下，输入流的接收缓冲区是8096个字节（8K）。这个值是Java所建议的输入缓冲区的大小。如果这个默认值不能满足要求，可以用setReceiveBufferSize方法来重新设置缓冲区的大小。但最好不要将输入缓冲区设得太小，否则会导致传输数据过于频繁，从而降低网络传输的效率。
如果底层的Socket实现不支持SO_RCVBUF选项，这两个方法将会抛出SocketException例外。必须将size设为正整数，否则setReceiveBufferSize方法将抛出IllegalArgumentException例外。
7.SO_KEEPALIVE
public boolean getKeepAlive() throws SocketException
public void setKeepAlive(boolean on) throws SocketException
如果将这个Socket选项打开，客户端Socket每隔段的时间（大约两个小时）就会利用空闲的连接向服务器发送一个数据包。这个数据包并没有其它的作用，只是为了检测一下服务器是否仍处于活动状态。如果服务器未响应这个数据包，在大约11分钟后，客户端Socket再发送一个数据包，如果在12分钟内，服务器还没响应，那么客户端Socket将关闭。如果将Socket选项关闭，客户端Socket在服务器无效的情况下可能会长时间不会关闭。SO_KEEPALIVE选项在默认情况下是关闭的，可以使用如下的语句将这个SO_KEEPALIVE选项打开：
socket1.setKeepAlive(true);
8.SO_OOBINLINE
public boolean getOOBInline() throws SocketException
public void setOOBInline(boolean on) throws SocketException
如果这个Socket选项打开，可以通过Socket类的sendUrgentData方法向服务器发送一个单字节的数据。这个单字节数据并不经过输出缓冲区，而是立即发出。虽然在客户端并不是使用OutputStream向服务器发送数据，但在服务端程序中这个单字节的数据是和其它的普通数据混在一起的。因此，在服务端程序中并不知道由客户端发过来的数据是由OutputStream还是由sendUrgentData发过来的。下面是sendUrgentData方法的声明：
public void sendUrgentData(int data) throws IOException
虽然sendUrgentData的参数data是int类型，但只有这个int类型的低字节被发送，其它的三个字节被忽略。下面的代码演示了如何使用SO_OOBINLINE选项来发送单字节数据。
package mynet;
import java.net.*;
import java.io.*;
class Server
{
public static void main(String[] args) throws Exception
{
ServerSocket serverSocket = new ServerSocket(1234);
System.out.println("服务器已经启动，端口号：1234");
while (true)
{
Socket socket = serverSocket.accept();
socket.setOOBInline(true);
InputStream in = socket.getInputStream();
InputStreamReader inReader = new InputStreamReader(in);
BufferedReader bReader = new BufferedReader(inReader);
System.out.println(bReader.readLine());
System.out.println(bReader.readLine());
socket.close();
}
}
}
public class Client
{
public static void main(String[] args) throws Exception
{
Socket socket = new Socket("127.0.0.1", 1234);
socket.setOOBInline(true);
OutputStream out = socket.getOutputStream();
OutputStreamWriter outWriter = new OutputStreamWriter(out);
outWriter.write(67); // 向服务器发送字符"C"
outWriter.write("hello world\r\n");
socket.sendUrgentData(65); // 向服务器发送字符"A"
socket.sendUrgentData(322); // 向服务器发送字符"B"
outWriter.flush();
socket.sendUrgentData(214); // 向服务器发送汉字”中”
socket.sendUrgentData(208);
socket.sendUrgentData(185); // 向服务器发送汉字”国”
socket.sendUrgentData(250);
socket.close();
}
}
?
由于运行上面的代码需要一个服务器类，因此，在加了一个类名为Server的服务器类，关于服务端套接字的使用方法将会在后面的文章中详细讨论。在类Server类中只使用了ServerSocket类的accept方法接收客户端的请求。并从客户端传来的数据中读取两行字符串，并显示在控制台上。
测试
由于本例使用了127.0.0.1，因Server和Client类必须在同一台机器上运行。
运行Server
java mynet.Server
运行Client
java mynet.Client
在服务端控制台的输出结果
服务器已经启动，端口号：1234
ABChello world
中国
在ClienT类中使用了sendUrgentData方法向服务器发送了字符'A'(65)和'B'(66)。但发送'B'时实际发送的是322，由于sendUrgentData只发送整型数的低字节。因此，实际发送的是66。十进制整型322的二进制形式如图1所示。
图1 十进制整型322的二进制形式
从图1可以看出，虽然322分布在了两个字节上，但它的低字节仍然是66。
在Client类中使用flush将缓冲区中的数据发送到服务器。我们可以从输出结果发现一个问题，在Client类中先后向服务器发送了'C'、"hello world"r"n"、'A'、'B'。而在服务端程序的控制台上显示的却是ABChello world。这种现象说明使用sendUrgentData方法发送数据后，系统会立即将这些数据发送出去；而使用write发送数据，必须要使用flush方法才会真正发送数据。
在Client类中向服务器发送"中国"字符串。由于"中"是由214和208两个字节组成的；而"国"是由185和250两个字节组成的；因此，可分别发送这四个字节来传送"中国"字符串。
注意：在使用setOOBInline方法打开SO_OOBINLINE选项时要注意是必须在客户端和服务端程序同时使用setOOBInline方法打开这个选项，否则无法命名用sendUrgentData来发送数据。