Java——TCP/UDP区别（三次握手、四次挥手）

借鉴原文：https://blog.csdn.net/weixin_41835916/article/details/81413752

TCP、UDP区别

1、TCP是面向连接的，UDP是面向非连接的，所以TCP数据一般不会丢包，但速度比起UDP稍慢，不适合实时性要求高的数据传输，UDP速度快，但存在丢包风险，它相当于就是发（send）和收（recieve）。

2、每一条TCP连接都是点到点，UDP支持一对一，一对多，多对一和多对多的交互通信。

3、由于TCP要面对连接，所以消耗的资源肯定比较多，而UDP就比较少

TCP报文格式

上图中有几个字段需要重点介绍下：
（1）序号：Seq序号，占32位，用来标识从TCP源端向目的端发送的字节流，发起方发送数据时对此进行标记。
（2）确认序号：Ack序号，占32位，只有ACK标志位为1时，确认序号字段才有效，Ack=Seq+1。
（3）标志位：共6个，即URG、ACK、PSH、RST、SYN、FIN等，具体含义如下：
（4）URG：紧急指针（urgent pointer）有效。
（5）ACK：确认序号有效。
（6）PSH：接收方应该尽快将这个报文交给应用层。
（7）RST：重置连接。
（8）SYN：发起一个新连接。
（9）FIN：释放一个连接。

需要注意的是：
（1）不要将确认序号Ack与标志位中的ACK搞混了。
（2）确认方Ack=发起方Req+1，两端配对。

三次握手

最经典的三次握手的图

è¿éåå¾çæè¿°

（1）第一次握手：Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。
（2）第二次握手：Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。
（3）第三次握手：Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。

SYN攻击：
在三次握手过程中，Server发送SYN-ACK之后，收到Client的ACK之前的TCP连接称为半连接（half-open connect），此时Server处于SYN_RCVD状态，当收到ACK后，Server转入ESTABLISHED状态。SYN攻击就是Client在短时间内伪造大量不存在的IP地址，并向Server不断地发送SYN包，Server回复确认包，并等待Client的确认，由于源地址是不存在的，因此，Server需要不断重发直至超时，这些伪造的SYN包将产时间占用未连接队列，导致正常的SYN请求因为队列满而被丢弃，从而引起网络堵塞甚至系统瘫痪。SYN攻击时一种典型的DDOS攻击，检测SYN攻击的方式非常简单，即当Server上有大量半连接状态且源IP地址是随机的，则可以断定遭到SYN攻击了。

四次挥手：

è¿éåå¾çæè¿°

为了保证A发送的最后一个ACK报文能够到达B。这个ACK报文段有可能丢失，因而使处在LAST-ACK状态的B收不到对已发送的FIN+ACK报文段的确认。B会超时重传这个FIN+ACK报文段，而A就能在2MSL时间内收到这个重传的FIN+ACK报文段。如果A在TIME-WAIT状态不等待一段时间，而是在发送完ACK报文段后就立即释放连接，就无法收到B重传的FIN+ACK报文段，因而也不会再发送一次确认报文段。这样，B就无法按照正常的步骤进入CLOSED状态。
MSL指的是任何IP数据报能够在因特网上存活的最长时间。假设现在一个MSL的时候，接收端需要发送一个应答，这时候，我们也必须等待这个应答的消失，这个应答的消失也是需要一个MSL，所以我们需要等待2MSL。

由于TCP连接时全双工的，因此，每个方向都必须要单独进行关闭，这一原则是当一方完成数据发送任务后，发送一个FIN来终止这一方向的连接，收到一个FIN只是意味着这一方向上没有数据流动了，即不会再收到数据了，但是在这个TCP连接上仍然能够发送数据，直到这一方向也发送了FIN。首先进行关闭的一方将执行主动关闭，而另一方则执行被动关闭，上图描述的即是如此。
（1）第一次挥手：Client发送一个FIN，用来关闭Client到Server的数据传送，Client进入FIN_WAIT_1状态。
（2）第二次挥手：Server收到FIN后，发送一个ACK给Client，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号），Server进入CLOSE_WAIT状态。
（3）第三次挥手：Server发送一个FIN，用来关闭Server到Client的数据传送，Server进入LAST_ACK状态。
（4）第四次挥手：Client收到FIN后，Client进入TIME_WAIT状态，接着发送一个ACK给Server，确认序号为收到序号+1，Server进入CLOSED状态，完成四次挥手。

为什么建立连接是三次握手，而关闭连接却是四次挥手呢？
这是因为服务端在LISTEN状态下，收到建立连接请求的SYN报文后，把ACK和SYN放在一个报文里发送给客户端。而关闭连接时，当收到对方的FIN报文时，仅仅表示对方不再发送数据了但是还能接收数据，己方也未必全部数据都发送给对方了，所以己方可以立即close，也可以发送一些数据给对方后，再发送FIN报文给对方来表示同意现在关闭连接，因此，己方ACK和FIN一般都会分开发送。

TCP客户端（client）和服务器端（server）代码如下



import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class TCPClient {
	private static final String IPADDRESS="localhost";
	private static final int PORT=9000;
    //TCP客户端
	public static void main(String[] args) {
		Socket client=null;
		try {
			System.out.println("连接到主机："+IPADDRESS+",端口号："+PORT);
			client=new Socket(IPADDRESS,PORT);
			System.out.println("远程主机地址:"+client.getRemoteSocketAddress());
			
			OutputStream outToServer=client.getOutputStream();
			DataOutputStream out=new DataOutputStream(outToServer);
			out.writeUTF("Hello,this data package from "+client.getLocalSocketAddress());
			InputStream inFromServer=client.getInputStream();
			DataInputStream in=new DataInputStream(inFromServer);
			System.out.println("服务器响应："+in.readUTF());
		}
		catch (IOException e) {
			e.printStackTrace();
			// TODO: handle exception
		}
		
		// TODO Auto-generated method stub

	}
}

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;

public class TCPServer extends Thread {
	private static final int PORT = 9000;
	private static ServerSocket serverSocket;
	private static int count=0;
	public TCPServer(int port) throws IOException {
		serverSocket=new ServerSocket(port);
		serverSocket.setSoTimeout(1000000);
	}

	public void run() {
		Socket socket=null;
		try {
			while(true) {
				System.out.println("等待客户端的连接，端口号为："+serverSocket.getLocalPort());
				socket=serverSocket.accept();
				System.out.println("远程客户端主机地址为："+socket.getRemoteSocketAddress());
				InputStream inputFromClientInputStream=socket.getInputStream();
				DataInputStream inputStream=new DataInputStream(inputFromClientInputStream);
				System.out.println("接收到来自客户端["+count+"]的信息为："+inputStream.readUTF());
				OutputStream outputfromserver=socket.getOutputStream();
				DataOutputStream out=new DataOutputStream(outputfromserver);
				out.writeUTF("服务器的响应：谢谢连接。"+serverSocket.getLocalPort());
			}
		}catch (IOException e) {
			e.printStackTrace();
			// TODO: handle exception
		}finally {
			try {
				socket.close();
				serverSocket.close();
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) throws IOException {
		int port=9000;
		//因为连接到服务器的client可能不只一个，所以用一个额外的线程来处理数据接受
        //而用当前线程专门来连接客户端
		Thread thread = new TCPServer(port);
		thread.run();
		
		// TODO Auto-generated method stub

	}

}

在上述程序中，相当于为每一个连接生成一个单独的线程，这种方法并不能满足高性能服务器的要求。为使服务器实现更高的吞吐量，可以使用java.nio包中一些特性

UDP接收

UDP没有连接，只有发（send）和收（recieve），主要用的就是DatagramSocket和DatagramPack。

UDP客户端

package java_IO;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class UDPClient {

	public static void main(String[] args) throws IOException {
		int port=8080;
		InetAddress address=InetAddress.getByName("localhost");
		DatagramSocket socket=null;
		try {
			socket=new DatagramSocket();
			String data="你好，服务器";
			byte[] buf=data.getBytes();
			DatagramPacket packet=new DatagramPacket(buf, buf.length,address,port);
			System.out.println("向服务器发送信息："+data);
			socket.send(packet);
			buf=new byte[1024];
			packet=new DatagramPacket(buf, buf.length,address,port);
			socket.receive(packet);
			data=new String(packet.getData(),0,packet.getLength());
			System.out.println("你接收到的数据是："+data);

		} catch (SocketException e) {
			e.printStackTrace();
			// TODO: handle exception
		}finally {
			socket.close();
		}
		// TODO Auto-generated method stub

	}

}

UDP服务器

package java_IO;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class UDPServer {

	public static void main(String[] args) throws IOException {
		DatagramSocket socket=null;
		int port=8080;
		InetAddress address= InetAddress.getByName("localhost");
		try {
			socket=new DatagramSocket();
			while(true) {
				byte[] buf=new byte[1024];
				DatagramPacket packet=new DatagramPacket(buf, buf.length,address,port);
				socket.receive(packet);
				String ip=packet.getAddress().getHostAddress();
				System.out.println("数据来自于："+ip);
				String data=new String(packet.getData(),0,buf.length);
				int clientport=packet.getPort();
				System.out.println("端口号为："+clientport+"\n数据内容："+data);
				data="你好，我是服务器。";
				buf=data.getBytes();
				packet=new DatagramPacket(buf, buf.length,address,clientport);
				socket.send(packet);
			}
		} catch (SocketException e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			socket.close();
		}
		// TODO Auto-generated method stub

	}

}

UDP与TCP在java编程中用到的一些方法：可以在这篇文章中找到：https://blog.csdn.net/jklcc1/article/details/81457359

Java——TCP/UDP区别（三次握手、四次挥手）

猜你喜欢