JavaSE——网络编程（UDP/TCP）

Posted 2023-04-01 javaHane

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaSE——网络编程（UDP/TCP）相关的知识，希望对你有一定的参考价值。

网络编程入门

网络编程概述

计算机网络

是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统
网络编程

在网络通信协议下，不同计算机上运行的程序，可以进行数据传输

网络编程三要素

IP地址

要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识
端口

网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区分这些应用程序呢？如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序了。也就是应用程序的标识
协议

通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。常见的协议有UDP协议和TCP协议

IP地址

IP地址：是网络中设备的唯一标识

IP地址分为两大类
- IPv4：是给每个连接在网络上的主机分配一个32bit地址。按照TCP/IP规定，IP地址用二进制来表示，每个IP地址长32bit，也就是4个字节。例如一个采用二进制形式的IP地址是“11000000 10101000 00000001 01000010”，这么长的地址，处理起来也太费劲了。为了方便使用，IP地址经常被写成十进制的形式，中间使用符号“.”分隔不同的字节。于是，上面的IP地址可以表示为“192.168.1.66”。IP地址的这种表示法叫做“点分十进制表示法”，这显然比1和0容易记忆得多
- IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。为了扩大地址空间，通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，这样就解决了网络地址资源数量不够的问题
DOS常用命令：
- ipconfig：查看本机IP地址
- ping IP地址：检查网络是否连通
特殊IP地址：
- 127.0.0.1：是回送地址，可以代表本机地址，一般用来测试使用

InetAddress

InetAddress：此类表示Internet协议（IP）地址

方法名	说明
static InetAddress getByName(String host)	确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
String getHostName()	获取此IP地址的主机名
String getHostAddress()	返回文本显示中的IP地址字符串

端口和协议

端口
- 设备上应用程序的唯一标识
端口号
- 用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败
协议
- 计算机网络中，连接和通信的规则被称为网络通信协议
UDP协议
- 用户数据报协议(User Datagram Protocol)
- UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。
- 由于使用UDP协议消耗系统资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输
- 例如视频会议通常采用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议
TCP协议
- 传输控制协议 (Transmission Control Protocol)
- TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”
- 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠
  
  第一次握手，客户端向服务器端发出连接请求，等待服务器确认
  
  第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求
  
  第三次握手，客户端再次向服务器端发送确认信息，确认连接
- 完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等

UDP通信程序

UDP发送数据

Java中的UDP通信
- UDP协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送，接收数据的对象，因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念
- Java提供了DatagramSocket类作为基于UDP协议的Socket

构造方法

方法名	说明
DatagramSocket()	创建数据报套接字并将其绑定到本机地址上的任何可用端口
DatagramPacket(byte[] buf,int len,InetAddress add,int port)	创建数据包,发送长度为len的数据包到指定主机的指定端口

相关方法

方法名说明

void send(DatagramPacket p) 发送数据报包

void close() 关闭数据报套接字

void receive(DatagramPacket p) 从此套接字接受数据报包
发送数据的步骤
- 创建发送端的Socket对象(DatagramSocket)
- 创建数据，并把数据打包
- 调用DatagramSocket对象的方法发送数据
- 关闭发送端

方法名	说明
void send(DatagramPacket p)	发送数据报包
void close()	关闭数据报套接字
void receive(DatagramPacket p)	从此套接字接受数据报包

代码演示

public class SendDemo 
    public static void main(String[] args) throws IOException 
        //创建发送端的Socket对象(DatagramSocket)
        // DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口
        DatagramSocket ds = new DatagramSocket();

        //创建数据，并把数据打包
        //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        //构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。
        byte[] bys = "hello,udp,我来了".getBytes();

        DatagramPacket dp = new DatagramPacket(bys,bys.length,InetAddress.getByName("127.0.0.1"),10086);

        //调用DatagramSocket对象的方法发送数据
        //void send(DatagramPacket p) 从此套接字发送数据报包
        ds.send(dp);

        //关闭发送端
        //void close() 关闭此数据报套接字
        ds.close();

UDP接收数据

接收数据的步骤
- 创建接收端的Socket对象(DatagramSocket)
- 创建一个数据包，用于接收数据
- 调用DatagramSocket对象的方法接收数据
- 解析数据包，并把数据在控制台显示
- 关闭接收端
构造方法

方法名说明

DatagramPacket(byte[] buf, int len) 创建一个DatagramPacket用于接收长度为len的数据包
相关方法

方法名说明

byte[] getData() 返回数据缓冲区

int getLength() 返回要发送的数据的长度或接收的数据的长度

方法名	说明
DatagramPacket(byte[] buf, int len)	创建一个DatagramPacket用于接收长度为len的数据包

方法名	说明
byte[] getData()	返回数据缓冲区
int getLength()	返回要发送的数据的长度或接收的数据的长度

示例代码

public class ReceiveDemo 
    public static void main(String[] args) throws IOException 
        //创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(12345);

        //创建一个数据包，用于接收数据
        byte[] bys = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bys, bys.length);

        //调用DatagramSocket对象的方法接收数据
        ds.receive(dp);

        //解析数据包，并把数据在控制台显示
        System.out.println("数据是：" + new String(dp.getData(), 0,                                             dp.getLength()));

UDP通信程序练习

案例需求

UDP发送数据：数据来自于键盘录入，直到输入的数据是886，发送数据结束

UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收

代码实现

/*
    UDP发送数据：
        数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class SendDemo 
    public static void main(String[] args) throws IOException 
        //创建发送端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();
        //键盘录入数据
        Scanner sc = new Scanner(System.in);
        while (true) 
            String s = sc.nextLine();
            //输入的数据是886，发送数据结束
            if ("886".equals(s)) 
                break;
            
            //创建数据，并把数据打包
            byte[] bys = s.getBytes();
            DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.1.66"), 12345);

            //调用DatagramSocket对象的方法发送数据
            ds.send(dp);
        
        //关闭发送端
        ds.close();
    


/*
    UDP接收数据：
        因为接收端不知道发送端什么时候停止发送，故采用死循环接收
 */
public class ReceiveDemo 
    public static void main(String[] args) throws IOException 
        //创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(12345);
        while (true) 
            //创建一个数据包，用于接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);
            //调用DatagramSocket对象的方法接收数据
            ds.receive(dp);
            //解析数据包，并把数据在控制台显示
            System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength()));
        
        //关闭接收端
//        ds.close();

UDP三种通讯方式

单播

单播用于两个主机之间的端对端通信
组播

组播用于对一组特定的主机进行通信
广播

广播用于一个主机对整个局域网上所有主机上的数据通信

UDP组播实现

实现步骤
- 发送端
  1. 创建发送端的Socket对象(DatagramSocket)
  2. 创建数据，并把数据打包(DatagramPacket)
  3. 调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址)
  4. 释放资源
- 接收端
  1. 创建接收端Socket对象(MulticastSocket)
  2. 创建一个箱子,用于接收数据
  3. 把当前计算机绑定一个组播地址
  4. 将数据接收到箱子中
  5. 解析数据包,并打印数据
  6. 释放资源

代码实现

// 发送端
public class ClinetDemo 
    public static void main(String[] args) throws IOException 
        // 1. 创建发送端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();
        String s = "hello 组播";
        byte[] bytes = s.getBytes();
        InetAddress address = InetAddress.getByName("224.0.1.0");
        int port = 10000;
        // 2. 创建数据，并把数据打包(DatagramPacket)
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
        // 3. 调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址)
        ds.send(dp);
        // 4. 释放资源
        ds.close();
    

// 接收端
public class ServerDemo 
    public static void main(String[] args) throws IOException 
        // 1. 创建接收端Socket对象(MulticastSocket)
        MulticastSocket ms = new MulticastSocket(10000);
        // 2. 创建一个箱子,用于接收数据
        DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
        // 3. 把当前计算机绑定一个组播地址,表示添加到这一组中.
        ms.joinGroup(InetAddress.getByName("224.0.1.0"));
        // 4. 将数据接收到箱子中
        ms.receive(dp);
        // 5. 解析数据包,并打印数据
        byte[] data = dp.getData();
        int length = dp.getLength();
        System.out.println(new String(data,0,length));
        // 6. 释放资源
        ms.close();

UDP广播实现

实现步骤
- 发送端
  1. 创建发送端Socket对象(DatagramSocket)
  2. 创建存储数据的箱子,将广播地址封装进去
  3. 发送数据
  4. 释放资源
- 接收端
  1. 创建接收端的Socket对象(DatagramSocket)
  2. 创建一个数据包，用于接收数据
  3. 调用DatagramSocket对象的方法接收数据
  4. 解析数据包，并把数据在控制台显示
  5. 关闭接收端

代码实现

// 发送端
public class ClientDemo 
    public static void main(String[] args) throws IOException 
        // 1. 创建发送端Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();
        // 2. 创建存储数据的箱子,将广播地址封装进去
        String s = "广播 hello";
        byte[] bytes = s.getBytes();
        InetAddress address = InetAddress.getByName("255.255.255.255");
        int port = 10000;
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
        // 3. 发送数据
        ds.send(dp);
        // 4. 释放资源
        ds.close();
    


// 接收端
public class ServerDemo 
    public static void main(String[] args) throws IOException 
        // 1. 创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(10000);
        // 2. 创建一个数据包，用于接收数据
        DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
        // 3. 调用DatagramSocket对象的方法接收数据
        ds.receive(dp);
        // 4. 解析数据包，并把数据在控制台显示
        byte[] data = dp.getData();
        int length = dp.getLength();
        System.out.println(new String(data,0,length));
        // 5. 关闭接收端
        ds.close();

TCP发送数据

Java中的TCP通信
- Java对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。
- Java为客户端提供了Socket类，为服务器端提供了ServerSocket类

构造方法

方法名	说明
Socket(InetAddress address,int port)	创建流套接字并将其连接到指定IP指定端口号
Socket(String host, int port)	创建流套接字并将其连接到指定主机上的指定端口号

相关方法

方法名说明

InputStream getInputStream() 返回此套接字的输入流

OutputStream getOutputStream() 返回此套接字的输出流

方法名	说明
InputStream getInputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

示例代码

public class Client 
    public static void main(String[] args) throws IOException 
        //TCP协议，发送数据

        //1.创建Socket对象
        //细节：在创建对象的同时会连接服务端
        //      如果连接不上，代码会报错
        Socket socket = new Socket("127.0.0.1",10000);

        //2.可以从连接通道中获取输出流
        OutputStream os = socket.getOutputStream();
        //写出数据
        os.write("aaa".getBytes());

        //3.释放资源
        os.close();
        socket.close();

TCP接收数据

构造方法

方法名说明

ServletSocket(int port) 创建绑定到指定端口的服务器套接字
相关方法

方法名说明

Socket accept() 监听要连接到此的套接字并接受它
注意事项
1. accept方法是阻塞的,作用就是等待客户端连接
2. 客户端创建对象并连接服务器,此时是通过三次握手协议,保证跟服务器之间的连接
3. 针对客户端来讲,是往外写的,所以是输出流针对服务器来讲,是往里读的,所以是输入流
4. read方法也是阻塞的
5. 客户端在关流的时候,还多了一个往服务器写结束标记的动作
6. 最后一步断开连接,通过四次挥手协议保证连接终止
三次握手和四次挥手
- 三次握手
- 四次挥手

方法名	说明
ServletSocket(int port)	创建绑定到指定端口的服务器套接字

方法名	说明
Socket accept()	监听要连接到此的套接字并接受它

示例代码

public class Server 
    public static void main(String[] args) throws IOException 
        //TCP协议，接收数据

        //1.创建对象ServerSocker
        ServerSocket ss = new ServerSocket(10000);

        //2.监听客户端的链接
        Socket socket = ss.accept();

        //3.从连接通道中获取输入流读取数据
        InputStream is = socket.getInputStream();
        int b;
        while ((b = is.read()) != -1)
            System.out.println((char) b);
        

        //4.释放资源
        socket.close();
        ss.close();

Linux----网络传输层UDP/TCP

引入

①端口号

端口号标识一个主机上进行通信的不同程序
在TCP/IP协议中, 用 “源IP”, “源端口号”, “目的IP”, “目的端口号”, “协议号” 这样一个五元组来标识一个通信

②端口号划分

0 - 1023: 知名端口号, HTTP, FTP, SSH等这些广为使用的应用层协议, 他们的端口号都是固定的
1024 - 65535: 操作系统动态分配的端口号. 客户端程序的端口号, 就是由操作系统从这个范围分配的

③知名端口号

比如：

ssh服务器, 使用22端口
ftp服务器, 使用21端口
telnet服务器, 使用23端口
http服务器, 使用80端口
https服务器, 使用443
sunproxyadmin: 使用8081端口

执行命令vim /etc/services可以查看端口号

④netstat、pidof、killall、ps、 awk、xargs？？？？

netstat：
语法： netstat [选项]
功能：查看网络状态
常用选项：

-n 拒绝显示别名，能显示数字的全部转化成数字
-l 仅列出有在 Listen (监听) 的服務状态
-p 显示建立相关链接的程序名
-t (tcp)仅显示tcp相关选项
-u (udp)仅显示udp相关选项
-a (all)显示所有选项，默认不显示LISTEN相关

例如tcp：

pidof 【进程名】：查看进程的pid

killall
功能：kill和ps grep等的结合体，用来使用进程名称来杀死进程
参数：

-e：对长名称进行精确匹配；
-l：忽略大小写的不同；
-p：杀死进程所属的进程组；
-i：交互式杀死进程，杀死进程前需要进行确认；
-l：打印所有已知信号列表；
-q：如果没有进程被杀死。则不输出任何信息；
-r：使用正规表达式匹配要杀死的进程名称；
-s：用指定的进程号代替默认信号“SIGTERM”；
-u：杀死指定用户的进程

ps axj | grep 【进程名】：查看为【进程名】的所有进程
ps axj | hread -nl && ps axj | grep 【进程名】
ps axj | grep 【进程名】| grep -v grep | awk ‘print $2’ | xargs kill -p//第二列
gawk 列处理工具
输入记录中的每个字段都可以通过其位置来引用：$1、$2 等等。 $0 是整个记录。字段不需要被常量引用： n = 5 print $n 打印输入记录中的第五个字段
xargs ：Linux xargs 命令

⑤所有协议需要解决的两个问题：

需要解决：

如何将自己的报头和有效载荷分离的问题
任何协议都必须解决，要将自己的有效载荷交付给，上层的哪一个协议

1）UDP

①UDP协议段格式

16位UDP长度, 表示整个数据报(UDP首部+UDP数据)的最大长度;如果校验和出错, 就会直接丢弃
所有协议需要解决的两个问题(对于UDP):

通过定长报头
16位目的端口号
（1.为什么socket编程中的port是16位的因为协议是16位的 2.为什么server要绑定，因为需要向上层协议交付）

UDP或者TCP是在内核里面，tcp/ ip协议栈，本质也是Linux内核的一部分
由于Linux内核是用C语言实现的-->内核中，我们的报头其实是位段
struct udp_header 
	uint32_t src_ port: 16
	uint32_t dst_ port:16;
	uint32_t udp_ length: 16:
	uint32_t udp_ check: 16;
位段是一种类型，可以定义变量->开辟空间，保存数据->填充报头本质上就是给位段类型对应的变量赋值

②UDP缓冲区

sendto, recvfrom，read，write，send, recv等本质并不是把数据发送到网络中，而是将用户数据拷贝到udp/tcp的发送缓冲区，或者将内核缓冲区中的数据，拷贝到用户
OS中的传输层协议来决定什么时候发送数据，发送多少数据，丢包了该干嘛(UDP丢包了不管)

UDP具有接收缓冲区. 但是这个接收缓冲区不能保证收到的UDP报的顺序和发送UDP报的顺序一致; 如果缓冲区满了, 再到达的UDP数据就会被丢弃;
UDP的socket能同时读写，全双工

③UDP特点及注意事项

UDP传输的过程.

无连接: 知道对端的IP和端口号就直接进行传输, 不需要建立连接;
不可靠: 没有确认机制, 没有重传机制; 如果因为网络故障该段无法发到对方, UDP协议层也不会给应用层返回任何错误信息;(注意不可靠是中性词)
面向数据报: 不能够灵活的控制读写数据的次数和数量

注意事项：

UDP协议首部中有一个16位的最大长度. 也就是说一个UDP能传输的数据最大长度是64K(包含UDP首部).，然而64K在当今的互联网环境下, 是一个非常小的数字.，如果我们需要传输的数据超过64K, 就需要在应用层手动的分包, 多次发送, 并在接收端手动拼装

④基于UDP的协议

NFS: 网络文件系统
TFTP: 简单文件传输协议
DHCP: 动态主机配置协议
BOOTP: 启动协议(用于无盘设备启动)
DNS: 域名解析协议

2）TCP

引入

冯诺伊曼体系结构中，（硬件与硬件之间是互相独立的）独立组件是通过“线”做到数据的传导的即便是在本主机内部，各个设备间都要有自己的协议(功能性问题，比如SCSI HBA PCI …)

专门设计TCP/IP协议是因为通信的设备之间“线更长了，传播的距离更远了，数据更容易丢失

TCP解决传输过程中的可靠性问题
IP解决定位设备问题

所以万物皆可系统化，皆可网络化

①TCP协议段格式

首先：任何协议都要先解决的两个问题：

分离有效载荷 (位首部长度，定长报头+自描述报头长度4bit(包括选项) 区分报头和有效载荷)
将有效载荷传给上一层协议 ( )

TCP协议段格式：

注意：

这里的4位首部长度，单位是四字节，比如：如果报头长度20个字节，4位首部长度就是20/4=5 二进制0101
标准的TCP报头为20个字节最大报头长度为60字节（可携带选项40字节）(4位首部长度-20就可判断是否继续读取option)

32位序号和 32位确认序号

确认应答机制(ACK)保证了可靠性：

不是对最新数据的可靠性保证 (最新数据可靠性不能被保证，只有收到应答才代表发出的消息被收到，可靠) ，而是对历史数据的可靠性进行保证

TCP是全双工的：

需要保证双向可靠性，双方需要确认应答机制，并遵守

host1向host2发送消息不一定是发一条，host2回一条，可能是发送多条，host2再回复多条，在这个过程中，每个报文可能选择的路由路径都是不同的，不同路径的通畅程度也不同（不可靠）

所以，在TCP的报头中有序号，可以对报文进行顺序重排(保证按序到达)

无论是请求还是应答都是：

tcp数据段：tcp报文+有效载荷 (应答可能没有有效载荷)

为什么要有一对32位序号？

任何请求可能是应答也可能是数据发送，所以，需要确认序号，来对对方的报文进行确认，同时也需要序号来保证报文到对方的按序到达

注意：图中没有体现出带字节数据的情况

32位序号：（参考关于ISN）

初始序列号(ISN)，是客户端随机产生的一个值，初始序列号(ISN)随时间而变化的，而且不同的操作系统也会有不同的实现方式 之后序号就是对方的确认序号

32位确认序号(32位序号+1)：

告诉发送者下一次从哪里开始发
注意：确认号是第一次发送的时候是0之后是对方发来的序号+1
（比如发送方发送了一个报文段序号为301的TCP段，这个段携带了100字节数据，则接收方应当回复的确认号是401）

16位窗口大小

TCP有自己的发送缓冲区和接受缓冲区，结合到之前的socket编程

write，send…本质是将用户数据拷贝到TCP的发送缓冲区
read，recv…本质是将内核的TCP缓冲区数据，拷贝到用户的缓冲区

当发送的数据过大，对方来不及接收， 16位窗口，表明自己的接收能力（接收缓冲区中剩余的空间大小）
站在OS的角度：

这种通过互相通报自己的接收能力(16位窗口大小)给对方，以达到两个方向上的传输速度的控制叫做流量控制
同时也可以看作在网络层面上生产者消费者的应用

16位紧急指针

因为tcp是按序到达的，所以，如果想让后续的数据被优先读取并处理，是不可能的，所以TCP提供了优先处理数据的能力，就是设置TCP中的URG标志位，紧急数据标志位，结合紧急指针使用(只能有一字节的紧急数据)

在socket编程中send和recv有一个flag选项：可以填写MSG_OOB来设置紧急数据和优先处理紧急数据

send
recv

6位标志位（16位紧急指针）

标志位(0 or 1) 作用
URG(urgent) 紧急指针是否有效
ACK(acknowledgement) 确认号是否有效
PSH(push) 提示接收端应用程序立刻从TCP缓冲区把数据读走
RST(reset) 对方要求重新建立连接; 我们把携带RST标识的称为复位报文段
SYN(synchronous) 请求建立连接; 我们把携带SYN标识的称为同步报文段
FIN(finish) 通知对方, 本端要关闭了, 我们称携带FIN标识的为结束报文段

为什么一定要SYN：

服务器收到tcp报文的时候，一定会在同一时间段，收到多种报文，为了保证数据正常通信，此时接收方就使用SYN如何区分，这些报文中，哪些是断开链接，哪些是建立链接的

解释RST：

在三次握手场景中如果最后一次ACK失败，client会仍然认为建立是成功的(第三次没有应答)，server会认为建立链接失败，在这时，认为成功的client就会向server发送数据，server在建立连接失败的情况下收到数据就会向client发送RST=1，要求重新建立连接

为什么一定是三次握手：

假设我们是4次握手，也就是多了一次ACK，但是更重要的是，认为建立连接成功的一方由client变为了server
连接可能很多，OS需要管理，(维护一个链接是有成本的(时间+空间), 且建立连接并不是必须100%建立成功，如果黑客想要攻击server，只需要向server发起大量的连接请求，但是在最后一次时不接收server的ACK，这样server认为建立成功，增加大量维护连接的成本，导致瘫痪，所以我们必须使用奇数次的握手
TCP是全双工的，需要SYN - > SYN+ACK 一来一回两次验证网络信道的通畅程度，所以三次是成本最低的选择

标志位(0 or 1)	作用
URG(urgent)	紧急指针是否有效
ACK(acknowledgement)	确认号是否有效
PSH(push)	提示接收端应用程序立刻从TCP缓冲区把数据读走
RST(reset)	对方要求重新建立连接; 我们把携带RST标识的称为`复位报文段`
SYN(synchronous)	请求建立连接; 我们把携带SYN标识的称为`同步报文段`
FIN(finish)	通知对方, 本端要关闭了, 我们称携带FIN标识的为`结束报文段`

②确认应答(ACK)机制（Linux内核 MARK）

TCP将每个字节的数据都进行了编号. 即为32位序列号(sequence number)
TCP发送与接收缓冲区，可以简单理解为字符数组char send_buffer[MAXSIZE], char recv_buffer[MAXSIZE], 数组下标就是天然的序列号(操作系统中是用其他方式实现的)

③超时重传机制

有两种情况会触发超时重传机制：

1.ACK丢包

当在间隔时间内client向server发送数据，仍会触发RST
重传SYN+ACK重复的解决方案（TCP层有去重能力，每个报文都有序列号）

2.普通丢包

间隔时间：

但是这个时间的长短, 随着网络环境的不同, 是有差异的.
如果超时时间设的太长, 会影响整体的重传效率;
如果超时时间设的太短, 有可能会频繁发送重复的包

TCP为了保证无论在任何环境下都能比较高性能的通信, 因此会动态计算这个最大超时时间.

Linux中(BSD Unix和Windows也是如此), 超时以500ms为一个单位进行控制, 每次判定超时重发的超时时间都是500ms的整数倍.
如果重发一次之后, 仍然得不到应答, 等待 2*500ms 后再进行重传.
如果仍然得不到应答, 等待 4*500ms 进行重传. 依次类推, 以指数形式递增.
累计到一定的重传次数, TCP认为网络或者对端主机出现异常, 强制关闭连接

以上是关于JavaSE——网络编程（UDP/TCP）的主要内容，如果未能解决你的问题，请参考以下文章

网络编程UDP/TCP协议

网络编程 ———— Java Socket(UDP/TCP 套接字)

Windows socket+IP+UDP+TCP网络基础

java高性能编程基础 - TCP与UDP的详细解读

TCP与UDP的区别

Linux 网络编程4网络层--UDP/TCP协议,3次握手4次挥手粘包问题等

JavaSE——网络编程（UDP/TCP）

网络编程入门

网络编程概述

网络编程三要素

IP地址

InetAddress

端口和协议

UDP通信程序

UDP发送数据

UDP接收数据

UDP通信程序练习

UDP三种通讯方式

UDP组播实现

UDP广播实现

TCP发送数据

TCP接收数据

Linux----网络传输层UDP/TCP

网络传输层UDP/TCP

引入

①端口号

②端口号划分

③知名端口号

④netstat、pidof、killall、ps、 awk、xargs？？？？

⑤所有协议需要解决的两个问题：

1）UDP

①UDP协议段格式

②UDP缓冲区

③UDP特点及注意事项

④基于UDP的协议

2）TCP

引入

①TCP协议段格式

32位序号 和 32位确认序号

16位窗口大小

16位紧急指针

6位标志位（16位紧急指针）

②确认应答(ACK)机制（Linux内核 MARK）

③超时重传机制

32位序号和 32位确认序号