1. 首页
  2. 文章中心
  3. tcp/ip

TCP和UDP在Java中的应用网络的七层TCP和UDP的区别三次握手和四次挥手Socket编程UDP编程例子

109 阅读 0 评论
我是靠谱客的博主 朴素小懒虫，这篇文章主要介绍TCP和UDP在Java中的应用网络的七层TCP和UDP的区别三次握手和四次挥手Socket编程UDP编程例子，现在分享给大家，希望可以做个参考。

网络的七层在这里插入图片描述

网络层：ip协议（IPV4，IPV6）
传输层：TCP协议和UDP协议
应用层： HTTP协议

TCP和UDP的区别

维度TCPUDP
可靠性可靠不可靠
速度稍慢更快
通信方式点对点点对点、一对多、多对多
通信内容字节码数据报
应用场景传输文件聊天、视频、语音

三次握手和四次挥手

TCP（传输控制协议 Transfer Control Protocol）

建立TCP连接需要通过三次握手机制在服务端和客户端之间建立连接

三次握手（Three-way Handshake）其实就是指建立一个TCP连接时，需要客户端和服务器总共发送3个包。进行三次握手的主要作用就是为了确认双方的接收能力和发送能力是否正常、指定自己的初始化序列号为后面的可靠性传送做准备。实质上其实就是连接服务器指定端口，建立TCP连接，并同步连接双方的序列号和确认号，交换TCP窗口大小信息。

在这里插入图片描述
三次握手：

  1. 客户端发送信号量SYN=1 和序列号seq=J 给服务端，客户端进入SYN_SENT(信号发送状态)，等待服务器回答
  2. 服务器收到客户端信号后，发送信号量SYN=1、ACK=1，应答值ack=J+1，新的序列号seq=K给客户端，服务器进入SYN_RCVD(收到信号)状态
  3. 客户端收到服务器的应答消息，发送ACK=1，和应答值ack=K+1给服务器，客户端和服务器都进入ESTABLISHED（连接建立）状态

在socket编程中，客户端执行connect()时，将触发三次握手。

客户端和服务端断开连接需要通过四次挥手

四次挥手：

  1. 客户端发送信号量FIN M给服务器端，进入FIN_WAIT1状态
  2. 服务端收到后，返回ack M+1给客户端，进入CLOSE_WAIT状态
  3. 服务端在发送FIN N信号给客户端
  4. 客户端收到后，返回应答信号ACK=1 ack=N+1给服务端，连接关闭

在socket编程中，任何一方执行close()操作即可产生挥手操作。

在这里插入图片描述

Socket编程

Socket（套接字）基于TCP/IP协议的网络编程机制

服务端

ServerSocket类 ，用于对本机的某个端口进行监听

  • 创建
    ServerSocket（int port）port是端口号
  • 方法
    close() 关闭连接
    Socker accept() 接收客户端的Socket,会阻塞线程直到有客户端连接

客户端

Socket类，代表客户端向服务端发送连接，进行网络通知

  • 创建

    Socket(String ip,int port) 通过ip和端口连接服务端

  • 方法

    disconnect() 关闭

    OutputStream getOutputStream() 获得输出流

    InputStream getInputStream() 获得输入流

    注意：IO流关闭后，socket会自动关闭
    在这里插入图片描述

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/**
 * 服务端
 */
public class Server {

    public static final int PORT = 8888;

    public void start() {
        System.out.println("服务器启动了！");
        //创建服务端Socket
        try(ServerSocket serverSocket = new ServerSocket(PORT)){
            //接收客户端连接
            while(true) {
                Socket socket = serverSocket.accept();
                System.out.println("客户端连接了！" + socket.getInetAddress());
                //获得输入流,得到客户端发送的消息
                ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
                String str = in.readUTF();
                System.out.println("接收消息：" + str);
                //获得输出流
                ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
                out.writeUTF("服务器给你问好了！！");
                out.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new Server().start();
    }
}
/**
 * 客户端
 */
public class Client {

    /**
     * 发送消息
     */
    public void send(String ip,int port,String msg){
        //创建连接
        try(Socket socket = new Socket(ip,port)){
            //获得输出流
            ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
            out.writeUTF(msg);
            out.flush();
            //获得输入流
            ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
            String s = in.readUTF();
            System.out.println("服务器回应：" + s);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new Client().send("192.168.1.113",9999,"Hello，今天学点什么？？");
    }
}

UDP编程

数据报协议，类似广播，属于不可靠的协议，无连接

服务端

DatagramSocket(int port) 指定端口获得发送的数据报

客户端

DatagramSocket() 作为客户端使用

主要方法

receive(DatagramPacket) 接收数据包

send(DatagramPacket) 发送数据报

DatagramPacket 包

DatagramPacket(String ip,int port) 发送前指定ip和端口

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class UDPServer {

    public static final int PORT = 8888;

    public void start(){
        System.out.println("启动服务");
        //创建UDP服务端
        try {
            DatagramSocket server = new DatagramSocket(PORT);
            //接收数据报
            while(true) {
                byte[] buff = new byte[1024];
                DatagramPacket packet = new DatagramPacket(buff,0,buff.length);
                //将接收的数据放入数据报
                server.receive(packet);
                String msg = new String(packet.getData(),0,packet.getLength(),"UTF-8");
                System.out.println("接收到：" + msg);
            }
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new UDPServer().start();
    }

}

public class UDPClient {

    public void send(String ip,int port,String msg){
        //创建客户端
        try {
            DatagramSocket client = new DatagramSocket();
            //创建数据报
            byte[] buff = msg.getBytes();
            DatagramPacket packet = new DatagramPacket(buff,0,buff.length, InetAddress.getByName(ip),port);
            //发送数据报
            client.send(packet);
        } catch (SocketException | UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new UDPClient().send("127.0.0.1",8888,"Hello UDP!!");
    }
}

例子

1、用TCP连接做一个简易版的聊天室

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
/**
 * 输出流
 */
public class HandleWriteRunnable implements Runnable {
    private Socket socket;

    public HandleWriteRunnable(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.println("输入你想说的话");
                String msg = scanner.next();
                outputStream.writeUTF(msg);
                outputStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


/**
 * 输入流
 */
public class HandleReadRunnable implements Runnable {
    private Socket socket;

    public HandleReadRunnable(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
            while (true) {
                String msg = inputStream.readUTF();
                System.out.println(socket.getInetAddress() + msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}



/**
 * 客户端
 */
public class Client {
    public void send(String ip, int port) throws IOException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        //创建联接
        Socket socket = new Socket(ip, port);
        executorService.execute(new HandleReadRunnable(socket));
        executorService.execute(new HandleWriteRunnable(socket));

    }

    public static void main(String[] args) {
        try {
            new Client().send("192.168.1.141",5000);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


/**
 * 服务端
 */
public class Server {
    private final int PROT = 5000;

    public void start(){
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        System.out.println("服务器启动了");
        //创建服务器连接
        try( ServerSocket serverSocket = new ServerSocket(PROT)) {
            Scanner scanner = new Scanner(System.in);
            //接收客户端连接
           while (true){
               Socket socket = serverSocket.accept();
               System.out.println("客户端连接了"+socket.getInetAddress());
                //获得输入流，得到客户端发送的消息
               executorService.execute(new HandleWriteRunnable(socket));
               executorService.execute(new HandleReadRunnable(socket));
           }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new Server().start();
    }
}

2、写一个死锁案例（两个线程都持有对方需要的锁，又有需要对方持有的锁）

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/**
 * 写一个死锁案例（两个线程都持有对方需要的锁，又有需要对方持有的锁）
 */

public class Demo1 {
    Object lock1 = new Object();
    Object lock2 = new Object();

    public static void main(String[] args) throws InterruptedException {
        new Demo1().test1();
    }

    public void test1() throws InterruptedException {
        Thread a = new Thread(()->{
            synchronized (lock1){
                for (int i = 0; i <1000 ; i++) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                synchronized (lock2){
                    System.out.println("aaaaaaa");
                }
            }
        });

        Thread b = new Thread(()->{
            synchronized (lock2){
                for (int i = 0; i <1000 ; i++) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                synchronized (lock1){
                    System.out.println("bbbbbbb");
                }
            }
        });
        a.start();
        b.start();
    }
}

3、写一个线程交替输出案例（A线程循环输出A，B线程循环输出B，出现ABABABAB… )

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.hopu.Demo;

/**
 * 写一个线程交替输出案例（A线程循环输出A，B线程循环输出B，出现ABABABAB..... )
 */
public class Demo2 {
    int num;//用于交替输出
    public static final Object lock = new Object();

    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        new Thread(() -> {
            try {
                demo2.test1(0);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();
        new Thread(() -> {
            try {
                demo2.test1(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "B").start();
    }

    public void test1(int number) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            synchronized (lock) {
                while (num % 2 != number) {
                    lock.wait();
                }
                num++;
                System.out.println(Thread.currentThread().getName());
                lock.notifyAll();
            }
        }
    }
}

最后

以上就是朴素小懒虫最近收集整理的关于TCP和UDP在Java中的应用网络的七层TCP和UDP的区别三次握手和四次挥手Socket编程UDP编程例子的全部内容，更多相关TCP和UDP在Java中内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(72)

相关文章

java endpoint作用_多个控制 endpoints （非EP0）的用途是什么？
java endpoint作用_多个控制 endpoints （非EP0）的用途是什么？
Java之tcp简单应用
Java之tcp简单应用
java 使用tcp协议_TCP协议的基本规则和在Java中的使用
java 使用tcp协议_TCP协议的基本规则和在Java中的使用
Java中的TCP通信简单使用
Java中的TCP通信简单使用
TCP和UDP在Java中的应用网络的七层TCP和UDP的区别三次握手和四次挥手Socket编程UDP编程例子
TCP和UDP在Java中的应用网络的七层TCP和UDP的区别三次握手和四次挥手Socket编程UDP编程例子
java网络 TCP使用案例
java网络 TCP使用案例
传输层——TCP与UDP
传输层——TCP与UDP
TCP协议是什么，TCP协议适用场景
TCP协议是什么，TCP协议适用场景

评论列表共有 0 条评论

立即
投稿
返回
顶部