概述
什么是Socket
网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket。Socket通常用来实现客户端和服务端的连接。Socket是TCP/IP协议的一个十分流行的编程实现，一个Socket由一个IP地址和一个端口号唯一确定。
但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。
Socket通讯的过程
Server端Listen(监听)某个端口是否有连接请求，Client端向Server端发出Connect(连接)请求，Server端向Client端发回Accept（接受）消息。一个连接就建立起来了。Server端和Client 端都可以通过Send，Write等方法与对方通信。
对于一个功能齐全的Socket，都要包含以下基本结构，其工作过程包含以下四个基本的步骤：
（1） 创建Socket；
（2） 打开连接到Socket的输入/出流；
（3） 按照一定的协议对Socket进行读/写操作；
（4） 关闭Socket。
InetAdress
首先说明一下InetAdress类的用法，它代表一个IP地址对象，是网络通信的基础，后面讲TCP/UDP编程会大量使用该类。
Java提供了InetAdress类来代表IP地址，InetAdress下还有两个子类：Inet4Adress（IPv4）和Inet6Adress（IPv6）。
InetAdress类没有提供构造器，而是提供了下面两个静态方法来获取InetAdress对象：
InetAdress getByName(String ip)：根据主机IP获取对应InetAdress对象。
InetAdress getByAddress(Byte[] addr )：根据IP地址获取对应InetAdress对象。
InetAdress getLocalHost()：获取本地机器的InetAdress对象。
InetAdress还提供了如下几个方法来获取IP地址和主机名：
String getCanonicalHostName()：获取全限定域名
String getHostAdress()：获取IP地址字符串
String getHostName()：获取主机名
Boolean isReachable(int time)：测试指定时间内（ms）是否可以到达该地址
网络编程中两个主要的问题
一个是如何准确的定位网络上一台或多台主机，另一个就是找到主机后如何可靠高效的进行数据传输。
（1）在TCP/IP协议中IP层主要负责网络主机的定位，数据传输的路由，由IP地址可以唯一地确定Internet上的一台主机。
（2）而TCP层则提供面向应用的可靠（TCP）的或非可靠（UDP）的数据传输机制，这是网络编程的主要对象，一般不需要关心IP层是如何处理数据的。
目前较为流行的网络编程模型是客户机/服务器（C/S）结构。即通信双方一方作为服务器等待客户提出请求并予以响应。客户则在需要服务时向服务器提出申请。服务器一般作为守护进程始终运行，监听网络端口，一旦有客户请求，就会启动一个服务进程来响应该客户，同时自己继续监听服务端口，使后来的客户也能及时得到服务。
两类传输协议：TCP、UDP
TCP是Tranfer Control Protocol的简称，是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。
UDP是User Datagram Protocol的简称，是一种面向无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径发往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。
比较：
TCP：
1，面向连接的协议，在socket之间进行数据传输之前必然要建立连接，所以在TCP中需要连接时间。
2，TCP传输数据无大小限制，一旦连接建立起来，双方的socket就可以按统一的格式传输大的数据。
3，TCP是一个可靠的协议，它的重发机制确保接收方完全正确地获取发送方所发送的全部数据。
UDP：
1，每个数据报中都给出了完整的地址信息，因此无需要建立发送方和接收方的连接。
2，UDP传输数据时是有大小限制的，每个被传输的数据报必须限定在64KB之内。
3，UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方。
应用：
1，TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。但是可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽，因此TCP传输的效率不如UDP高。
2，UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序。例如视频会议系统，并不要求音频视频数据绝对的正确，只要保证连贯性就可以了，这种情况下显然使用UDP会更合理一些。
TCP编程
原理
TCP编程是基于ServerSocket和Socket来实现的。TCP协议控制两个通信实体相互通信的示意图如下：
从图上看两个通信实体并没有服务器、客户端之分，但那是两个通信实体已经建立链路后的示意图。在链路建立前，必须要有一个通信实体做出“主动姿态”，主动接收来自其他通信实体的连接请求，这方就是服务器端了。Java中能接收其他通信实体连接请求的类是ServerSocket，ServerSocket对象用来监听来自客户端的Socket连接，如果没有连接，它将一直处于等待状态。ServerSocket包含一个监听来自客户端连接请求的方法：
Socket accept();
如果接收到一个客户端的Socket连接请求，会返回一个与客户端Socket对应的服务端Socket，否则该方法一直处于等待状态，线程阻塞。
ServerSocket类提供如下构造器：
ServerSocket(int port);
使用指定端口来创建，port范围：0-65535。注意，在选择端口时，必须小心。每一个端口提供一种特定的服务，只有给出正确的端口，才能获得相应的服务。0~1023的端口号为系统所保留，例如http服务的端口号为80,telnet服务的端口号为21,ftp服务的端口号为23, 所以我们在选择端口号时，最好选择一个大于1023的数以防止发生冲突。
ServerSocket(int port, int backlog);
增加一个用来改变连接队列长度的参数backlog。
ServerSocket(int port, int backlog, InetAddress bindAddr);
在机器存在多个IP地址的情况下，bindAddr参数指定将ServerSocket绑定到指定IP。
当ServerSocket使用完毕，应使用close()方法来关闭此ServerSocket。通常情况下，服务器不应该只接收一个客户端请求，而应该不断接收来自客户端的请求，所以程序可以通过循环，不断调用ServerSocket的accept方法：
ServerSocket ss = new ServerSocket(30000);
while(true) {
Socket s = ss.accept();
...
}
客户端通常使用Socket来连接指定服务器，Socket类提供如下构造器：
Socket(InetAddress/String remoteAddress, int port);
创建连接到指定远程主机、远程端口的Socket，本地IP地址和端口使用默认值。
Socket(InetAddress/String remoteAddress, int port, InetAddress localAddr, int localPort);
绑定本地IP地址和端口，适用于本地主机有多个IP地址的情形。
上面两个构造器指定远程主机时既可以使用InetAddress来指定，也可以直接使用String对象来指定远程IP。本地主机只有一个IP地址时，使用第一个方法更简单。
实践
我们这里实现一个功能，客户端通过TCP协议传输一张图片到服务器端，并显示传输进度。
这里将服务端程序写成一个Android应用：
public class MainActivity extends AppCompatActivity {
private TextView text;
public static Toast toast = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
text = (TextView) findViewById(R.id.text);
text.setText("IP地址："+getLocalHostIp());
//启动服务器监听线程
new ServerListener().start();
}
public class ServerListener extends Thread {
@Override
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(30000);
// 循环的监听
while (true) {
Socket socket = serverSocket.accept();// 阻塞
runOnUiThread(new Runnable(){
@Override
public void run() {
showToast("有客户端连接到本机的30000端口！");
}
});
// 将socket传给新的线程
TransportSocket ts = new TransportSocket(socket);
ts.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public class TransportSocket extends Thread {
Socket socket;
int progress = 0;
public TransportSocket(Socket s) {
this.socket = s;
}
@Override
public void run() {
try {
File file = new File("/sdcard/receive.png"); //接收文件
if (!file.exists()) {
file.createNewFile();
}
BufferedInputStream is = new BufferedInputStream(socket.getInputStream()); // 读进
BufferedOutputStream os = new BufferedOutputStream(new FileOutputStream(file));// 写出
byte[] data = new byte[1024*5];// 每次读取的字节数
int len= -1;
while ((len=is.read(data) )!= -1) {
os.write(data,0,len);
progress+=len;//进度
runOnUiThread(new Runnable() {
@Override
public void run() {
showToast("接收进度:" + progress);
}
});
}
progress = 0;
is.close();
os.flush();
os.close();
socket.close(); //关闭socket
runOnUiThread(new Runnable() {
@Override
public void run() {
showToast("接收完成！");
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
}
//及时toast
public void showToast(String info) {
if (toast == null) {
toast = Toast.makeText(this, "", Toast.LENGTH_SHORT);
}
toast.setText(info);
toast.show();
}
// 获取本机IPv4地址
public static String getLocalHostIp() {
String ipaddress = "";
try {
Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces();
// 遍历所用的网络接口
while (en.hasMoreElements()) {
NetworkInterface nif = en.nextElement();// 得到每一个网络接口绑定的所有ip
Enumeration<InetAddress> inet = nif.getInetAddresses();
// 遍历每一个接口绑定的所有ip
while (inet.hasMoreElements()) {
InetAddress ip = inet.nextElement();
if (!ip.isLoopbackAddress() && ip instanceof Inet4Address) {
return ipaddress = ip.getHostAddress();
}
}
}
} catch (SocketException e) {
System.out.print("获取IP失败");
e.printStackTrace();
}
return ipaddress;
}
}
添加权限：
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
再来看看客户端代码，同样是一个Android应用：
public class MainActivity extends AppCompatActivity {
private Button button;
private int progress = 0;
private Toast toast = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
button = (Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v) {
ClientSocket cs = new ClientSocket();
cs.start();
}
});
}
public class ClientSocket extends Thread {
int progress = 0;
@Override
public void run() {
try {
Socket socket = new Socket("192.168.1.43", 30000); //服务器IP及端口
File file = new File("/sdcard/send.png");//发送文件，记得客户端此路径下必须要有此文件存在
BufferedInputStream is = new BufferedInputStream(new FileInputStream(file));
BufferedOutputStream os =new BufferedOutputStream(socket.getOutputStream());
// 读文件
double n = 1;
byte[] data = new byte[1024*5];//每次读取的字节数
int len=-1;
while ((len=is.read(data))!= -1) {
os.write(data,0,len);
progress+=len;//进度
runOnUiThread(new Runnable(){
@Override
public void run() {
showToast("发送进度:"+progress);
}
});
}
progress=0;
is.close();
os.flush();
os.close();
socket.close(); //关闭socket
runOnUiThread(new Runnable(){
@Override
public void run() {
showToast("发送完成！");
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
}
public void showToast(String info) {
if (toast == null) {
toast = Toast.makeText(this, "", Toast.LENGTH_SHORT);
}
toast.setText(info);
toast.show();
}
}
同样添加权限：
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
注意，这里Socket连接的服务器IP地址和端口必须保持和服务端应用的一致。上面服务端应用已经将其IP地址首页显示出来了。
同时运行服务端和客户端应用，这里要确保它们处于联网状态且处于同一个局域网。点击客户端开始传输按钮：
服务端显示：
发送完成后，可以看到，在服务器sdcard目录下会生成一张receive.png图片，内容与客户端的send.png完全一致。
UDP编程
原理
UDP是一种不可靠网络协议，双方Socket之间并没有虚拟链路，这两个Socket只是发送、接收数据报的对象。Java提供了DatagramSocket作为基于UDP协议的Socket，使用DatagramPacket代表DatagramSocket发送、接收的数据报。
DatagramSocket本身只是码头，不维护状态，不能产生IO流，唯一作用就是接收和发送数据报。看一下DatagramSocket构造函数：
DatagramSocket();
创建对象，绑定到本机默认IP地址，本机所有可用端口随机选择某个端口。
DatagramSocket(int port);
绑定到本机默认IP地址，指定端口。
DatagramSocket(int port, InetAdress addr);
绑定到指定IP地址，指定端口。
通常创建服务器时，我们创建指定端口DatagramSocket对象—-这样保证其他客户端可以将数据发送到该服务器。一旦得到DatagramSocket对象之后，可以通过如下两个方法接收和发送数据：
receive(DatagramPacket p);
从该DatagramSocket中接收数据。receive将一直等待（也就是说会阻塞调用该方法的线程），直到收到一个数据报为止。
send(DatagramPacket p);
以该DatagramSocket向外发送数据
使用DatagramSocket发送数据时，DatagramSocket并不知道数据的目的地，而是由DatagramPacket自身决定的。
当C/S程序使用UDP时，实际上并没有明显的客户端、服务器之分，双方都要建立一个DatagramSocket对象来发送和接收数据，一般把固定IP，固定端口的DatagramSocket所在程序作为服务器，因为该DatagramSocket可以主动接受客户端数据。
接下来看看DatagramPacket构造函数：
DatagramPacket(byte buf[], int length);
以一个空数组来创建DatagramPacket对象，该对象作用是接收DatagramSocket中的数据。
DatagramPacket(byte buf[], int offset, int length);
以一个空数组来创建DatagramPacket对象，并指定接收到的数据放入buf数组时从offset开始，最多放length个字节。
DatagramPacket(byte buf[], int length, InetAdress addr, int port);
以一个包含数据的数组来创建DatagramPacket对象，还指定了IP和端口—决定该数据目的地。
DatagramPacket(byte buf[], int offset, int length, InetAdress addr, int port);
创建用于发送的DatagramPacket对象，多指定了一个offset参数。
注：DatagramPacket同时还提供了getData()和setData()函数用来获取和设置封装在DatagramPacket对象里面的字节数组，即构造器里面的字节数组实参。
DatagramPacket提供了如下三个方法来获取发送者的IP和端口：
InetAdress getAdress();
当程序准备发送此数据报时，返回数据报目标主机的IP地址；当程序接收到一个数据报时，返回该数据报发送主机的IP地址。
int getPort();
和上面函数类似，只是获取的是端口。
SocketAdress getSocketAdress();
和上面函数类似，只是获取的是SocketAdress对象，SocketAdress封装了一个InetAdress对象和一个整形端口信息。
实践
我们接下来实现一个客户端和服务器的局域网聊天系统，消息的发送和接收是基于UDP协议的。
首先看客户端代码：
public class MainActivity extends AppCompatActivity {
private Button send_message;
private EditText edit;
private TextView content;
private Toast toast = null;
private DatagramSocket sendDS; //udp发送socket
private DatagramSocket receiveDS; //udp接收socket
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
edit = (EditText) findViewById(R.id.edit);
send_message = (Button) findViewById(R.id.send_message);
content = (TextView) findViewById(R.id.content);
send_message.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v) {
UdpSend us = new UdpSend();
us.start();
}
});
//启动UDP监听线程
new UdpReceive().start();
}
// 发送消息线程
class UdpSend extends Thread {
@Override
public void run() {
try {
runOnUiThread(new Runnable(){
@Override
public void run() {
if (edit.getText().toString().trim().isEmpty()) {
showToast("请输入消息！");
return;
} else {
content.setText(content.getText()+"\n我说："+edit.getText().toString());
edit.setText("");
}
}
});
byte[] data = edit.getText().toString().getBytes();
if (sendDS == null) {
sendDS = new DatagramSocket(null);
sendDS.setReuseAddress(true);
sendDS.bind(new InetSocketAddress(20000)); //发送端口20000
}
DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.1.43"), 25000); //接收端口25000
packet.setData(data);
sendDS.send(packet);
// sendDS.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 接收消息线程
class UdpReceive extends Thread {
@Override
public void run() {
//消息循环
while(true) {
try {
if(receiveDS == null){
receiveDS = new DatagramSocket(null);
receiveDS.setReuseAddress(true);
receiveDS.bind(new InetSocketAddress(25000)); //接收端口25000
}
byte[] data = new byte[1024 * 4];
DatagramPacket dp = new DatagramPacket(data, data.length);
dp.setData(data);
receiveDS.receive(dp); //阻塞式，等待服务器消息
// receiveDS.close();
final byte[] data2 = data.clone();
runOnUiThread(new Runnable(){
@Override
public void run() {
content.setText(content.getText()+"\n服务器说："+new String(data2));
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
public void showToast(String info) {
if (toast == null) {
toast = Toast.makeText(this, "", Toast.LENGTH_SHORT);
}
toast.setText(info);
toast.show();
}
}
服务器代码如下：
public class MainActivity extends AppCompatActivity {
private Button send_message;
private EditText edit;
private TextView content;
public static Toast toast = null;
public InetAddress clientAdress; //记录客户端IP地址
private DatagramSocket sendDS; //udp发送socket
private DatagramSocket receiveDS; //udp接收socket
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
edit = (EditText) findViewById(R.id.edit);
send_message = (Button) findViewById(R.id.send_message);
content = (TextView) findViewById(R.id.content);
send_message.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v) {
UdpSend us = new UdpSend();
us.start();
}
});
//启动UDP服务器监听线程
new UdpReceive().start();
}
// 发送消息线程
class UdpSend extends Thread {
@Override
public void run() {
try {
runOnUiThread(new Runnable(){
@Override
public void run() {
if (edit.getText().toString().trim().isEmpty()) {
showToast("请输入消息！");
return;
} else {
if (clientAdress == null) {
showToast("未获取客户端信息！");
return;
}
content.setText(content.getText()+"\n我说："+edit.getText().toString());
edit.setText("");
}
}
});
byte[] data = edit.getText().toString().getBytes();
if (sendDS == null) {
sendDS = new DatagramSocket(null);
sendDS.setReuseAddress(true);
sendDS.bind(new InetSocketAddress(20000)); //发送端口20000
}
DatagramPacket packet = new DatagramPacket(data, data.length, clientAdress, 25000);
packet.setData(data);
sendDS.send(packet);
// sendDS.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 接收消息线程
class UdpReceive extends Thread {
@Override
public void run() {
//消息循环
while(true) {
try {
if(receiveDS == null){
receiveDS = new DatagramSocket(null);
receiveDS.setReuseAddress(true);
receiveDS.bind(new InetSocketAddress(25000)); //接收端口25000
}
byte[] data = new byte[1024 * 4];
DatagramPacket dp = new DatagramPacket(data, data.length);
dp.setData(data);
receiveDS.receive(dp); //阻塞式，等待客户端消息
// receiveDS.close();
clientAdress = dp.getAddress(); //获取客户端IP，后面就可以发消息给客户端了
final byte[] data2 = data.clone();
runOnUiThread(new Runnable(){
@Override
public void run() {
content.setText(content.getText()+"\n客户端说："+new String(data2));
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
public void showToast(String info) {
if (toast == null) {
toast = Toast.makeText(this, "", Toast.LENGTH_SHORT);
}
toast.setText(info);
toast.show();
}
}
可以看到，服务器端代码和客户端基本一样，除了下面部分
clientAdress = dp.getAddress(); /**获取客户端IP，后面就可以发消息给客户端了*/
...
DatagramPacket packet = new DatagramPacket(data, data.length, clientAdress, 25000);
服务器端IP是固定的，但客户端却不是，所以服务器端需要利用客户端发过来的数据报获取客户端的IP地址并记录下来，之后就可以使用刚才获取的客户端IP地址clientAdress来向客户端发消息啦。
同时打开客户端和服务端应用，客户端先发送一条信息给客户端，客户端效果如下图：
服务端效果图：
ServerSocket 选项
ServerSocket 有以下 3 个选项.
SO_TIMEOUT: 表示等待客户连接的超时时间.
SO_REUSEADDR: 表示是否允许重用服务器所绑定的地址.
SO_RCVBUF: 表示接收数据的缓冲区的大小.
SO_TIMEOUT 选项
设置该选项: public void setSoTimeout(int timeout) throws SocketException
读取该选项: public int getSoTimeout() throws SocketException
这个选项与Socket 的选项相同。SO_TIMEOUT，以毫秒为单位，将此选项设为非零的超时值时，在与此 Socket 关联的 InputStream 上调用 read() 将只阻塞此时间长度。如果超过超时值，将引发 java.net.SocketTimeoutException，虽然 Socket 仍旧有效。选项必须在进入阻塞操作前被启用才能生效。超时值必须是 大于 0 的数。超时值为 0 被解释为无穷大超时值。
Socket设置读写超时：
Socket s = new Socket("172.0.0.1", 30000);
//读取服务器的进程一直阻塞，超过10s，抛出SocketTimeoutException异常
s.setSoTimeout(10000);
1
2
3
上面方法说白了只是设置read方法的超时时间，这个方法是堵塞的！Socket其实还有一个超时时间，即连接超时，可以通过下面方法设置。
Socket设置连接超时：
Socket s = new Socket();
//该Socket超过10s还没有连接到远程服务器，认为连接超时
s.connect(new InetAddress(host,port), 10000);
1
2
3
SO_REUSEADDR 选项
设置该选项: public void setResuseAddress(boolean on) throws SocketException
读取该选项: public boolean getResuseAddress() throws SocketException
这个选项与Socket 的选项相同, 用于决定如果网络上仍然有数据向旧的 ServerSocket 传输数据, 是否允许新的 ServerSocket 绑定到与旧的 ServerSocket 同样的端口上。SO_REUSEADDR 选项的默认值与操作系统有关, 在某些操作系统中, 允许重用端口, 而在某些操作系统中不允许重用端口。
当 ServerSocket 关闭时, 如果网络上还有发送到这个 ServerSocket 的数据, 这个ServerSocket 不会立即释放本地端口, 而是会等待一段时间, 确保接收到了网络上发送过来的延迟数据, 然后再释放端口。由于端口已经被占用, 使得程序无法绑定到该端口, 程序运行失败, 并抛出 BindException:
java.net.BindException: bind failed: EADDRINUSE (Address already in use)
为了确保一个进程关闭了 ServerSocket 后, 即使操作系统还没释放端口, 同一个主机上的其他进程还可以立即重用该端口, 可以调用 ServerSocket 的 setResuseAddress(true) 方法，而且必须在 ServerSocket 还没有绑定到一个本地端口之前调用, 否则执行serverSocket.setReuseAddress(true) 方法无效。 此外, 两个共用同一个端口的进程必须都调用 serverSocket.setResuseAddress(true) 方法, 才能使得一个进程关闭 ServerSocket 后, 另一个进程的 ServerSocket 还能够立刻重用相同的端口。
if(receiveDS == null){
receiveDS = new DatagramSocket(null);
receiveDS.setReuseAddress(true);
receiveDS.bind(new InetSocketAddress(25000));
}
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绑定到特定端口之前或之后, 调用 setReceiveBufferSize() 方法都有效. 例外情况下是如果要设置大于 64 KB 的缓冲区, 则必须在 ServerSocket 绑定到特定端口之前进行设置才有效。
执行 serverSocket.setReceiveBufferSize() 方法, 相当于对所有由 serverSocket.accept() 方法返回的 Socket 设置接收数据的缓冲区的大小。
---------------------
作者：huaxun66
来源：CSDN
原文：https://blog.csdn.net/huaxun66/article/details/53008542
版权声明：本文为博主原创文章，转载请附上博文链接！