【Java TCP/IP Soket】— 剖析TCP中的死锁

最新推荐文章于 2022-04-09 11:27:05 发布
最新推荐文章于 2022-04-09 11:27:05 发布
阅读量3.9k 收藏 8
点赞数 1
分类专栏： Java Socket 文章标签： Java TCP死锁 死锁 阻塞
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dabing69221/article/details/17397821
版权

前言

大家在编写Socket应用程序时，必须避免设计非常小心以避免出现死锁。例如，在建立连接后，发送端与接收端都尝试发送数据，显然将会导致死锁的发生。在前面中我们介绍了SendQ、RecvQ、Delivered队列，SendQ、RecvQ队列中缓冲区的容量在具体实现时会受到一定的限制。虽然它们使用的实际内存大小会动态的增长和收缩，还是需要一个硬性的限制，以防止行为异常的程序所控制的单独一个TCP连接将系统内存耗尽，如果与TCP的流控制机制结合使用，则可能导致另一种形式的死锁。


TCP中死锁分析

在TCP套接字中，一旦接收端的RecvQ队列缓冲区已满，TCP流控制机制就会产生作用，它阻止TCP传输发送端SendQ队列缓冲区的任何数据，直到接收端调用in.read( )方法将RecvQ队列缓冲区中的数据移动到Delivered队列中腾出空间（这里使用流控制机制目的是为了保证发送者不会发送太多数据，而导致超出了接收系统的处理能力）。

  

发送端可以持续的写出数据，直到SendQ队列缓冲区被填满，然而，如果，在SendQ队列缓冲区已满时调用out.write( )方法，则阻塞等该，直到SendQ队列缓冲区有新的空间为止。换句话说：发送端将数据传输到接收端的RendQ队列中时，如果此时RendQ队列缓冲区已经被填满，那么将会产生阻塞。直到接收端调用in.read( )方法将数据移动到Delivered队列中腾出空间为止。

  

TCP中死锁场景

下面考虑一个场景：

即主机A与主机B之间的一个连接，假设主机A和主机B上的SendQ、RecvQ队列缓冲区大小为500个字节，现在考虑一下 ”两个主机（A、B）中的程序试图同时发送1500个字节时的情况“。主机A上程序中的前500个字节已经传输到主机A中，另外的500个字节也已经复制到SendQ队列中，余下的500个字节将无法发送（因此，在主机A的程序中调用out.write( )方法将会阻塞），直到主机B中的RecvQ队列缓冲区中有空间空出来。然后，主机B上的程序也遇到了同样的情况。因此，在两个主机上程序的out.write( )方法的调用都将阻塞（永远都无法完成）。

  

以上的场景告诉我们：”在TCP套接字中，要仔细的设计协议，避免在两端发送大量数据时产生死锁“。


TCP中死锁例子

1.示例

下面，我们通过一个例子来模拟一下上述场景中的死锁问题，代码如下：

/*
 * 服务端
 */
public class TestServer
{
    public static void main(String[] args) throws IOException
    {
        System.out.println("服务端启动......");
        ServerSocket server = new ServerSocket(8888);

        Socket client = server.accept();
        OutputStream output = client.getOutputStream();
        InputStream input = client.getInputStream();

        byte[] temp = new byte[10];
        int realLen = 0;
        while ((realLen = input.read(temp)) != -1)
        {
            System.out.println("【服务端】正在发送数据......");
            output.write(temp, 0, realLen);
        }
        System.out.println("【客户端】发送数据完毕!");
        output.flush();

        client.close();
    }
}


/*
 * 客户端
 */
public class TestClient
{
    public static void main(String[] args) throws UnknownHostException,
            IOException
    {
        System.out.println("客户端启动......");
        Socket client = new Socket(InetAddress.getLocalHost(), 8888);

        OutputStream out = client.getOutputStream();
        InputStream in = client.getInputStream();
        FileInputStream fileIn = new FileInputStream(new File("D:\\杂乱\\桌面.jpg"));

        byte[] fileTemp = new byte[1024];
        int realFileLen = 0;
        while ((realFileLen = fileIn.read(fileTemp)) != -1)
        {
            System.out.println("【客户端】正在发送数据......");
            out.write(fileTemp, 0, realFileLen);
        }
        System.out.println("【客户端】发送数据完毕!");
        out.flush();
        client.shutdownOutput();

        ByteArrayOutputStream byteArray = new ByteArrayOutputStream();
        int realLen = 0;
        byte[] temp = new byte[10];
        while ((realLen = in.read(temp)) != -1)
        {
            byteArray.write(temp, 0, realLen);
        }
        byte[] recvByte = byteArray.toByteArray();

        System.out.println("客户端接收消息成功,消息长度:" + recvByte.length);

    }
}
运行上边的例子，我们发现：客户端与服务端程序都会被阻塞（永远也执行不完）。


2.剖析

下面我们分析一下阻塞原因：

我们把TestClient客户端类所在的主机为A，把TestServer服务端类所在的主机为B。在主机A与主机B之间建立了一条连接。现在主机A中的程序不断的向主机B的RecvQ队列中传输数据，而这时，主机B也不断的将RecvQ队列中的数据移动到DeliveredQ队列中，并把DeliveredQ队列中的数据移动到SendQ队列中，然后再把SendQ队列中的数据传输到主机A中的RecvQ队列中（注意：这个时候主机A还在不断的向主机B发送数据）—— 这样就会造成 ” 主机A中的RecvQ队列被填满，主机B上的程序调用out.write( )方法发送数据时就会阻塞，然而不幸的是：这个时候主机A依然不断的向主机B中的RecvQ队列中传输数据，直到RecvQ队列被填满，然后主机A上的程序调用out.write( )方法发送数据是就会阻塞“，所以，主机A的程序(客户端)与主机B的程序(服务端)都会阻塞，永远也执行不完！ 如下图所示：

     

TCP中死锁解决办法

   方案一：在不同的线程分别执行客户端的write( ) 和 read( )

   好处：可以边读边写，创建的缓冲区比较小，不会造成客户端中RecvQ队列被填满 , 相应的服务端中RecvQ队列也不会被填满；

   坏处：客户端中得使用不同的线程，分别进行write() 和 read( )操作；

/*
 * 服务端
 */
public class TestServer
{
    public static void main(String[] args) throws IOException
    {
        System.out.println("服务端启动......");
        ServerSocket server = new ServerSocket(8888);

        Socket client = server.accept();
        OutputStream output = client.getOutputStream();
        InputStream input = client.getInputStream();

        byte[] temp = new byte[10];
        int realLen = 0;
        while ((realLen = input.read(temp)) != -1)
        {
            System.out.println("【服务端】正在发送数据......");
            output.write(temp, 0, realLen);
        }
        System.out.println("【客户端】发送数据完毕!");
        output.flush();

        client.close();
    }
}


/*
 * 客户端
 */
public class TestClient
{
    public static void main(String[] args) throws UnknownHostException,
            IOException
    {
        System.out.println("客户端启动......");
        final Socket client = new Socket(InetAddress.getLocalHost(), 8888);

        final OutputStream out = client.getOutputStream();
        InputStream in = client.getInputStream();
        final FileInputStream fileIn = new FileInputStream(new File(
                "D:\\杂乱\\桌面.jpg"));

        // 使用一个子线程发送数据
        Thread handlerExecute = new Thread()
        {
            @Override
            public void run()
            {
                try
                {
                    byte[] fileTemp = new byte[1024];
                    int realFileLen = 0;

                    while ((realFileLen = fileIn.read(fileTemp)) != -1)
                    {
                        System.out.println("【客户端】正在发送数据......");
                        out.write(fileTemp, 0, realFileLen);
                    }
                    System.out.println("【客户端】发送数据完毕!");

                    out.flush();
                    client.shutdownOutput();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        };

        handlerExecute.start();

        // 使用主线程接收数据
        ByteArrayOutputStream byteArray = new ByteArrayOutputStream();
        int realLen = 0;
        byte[] temp = new byte[10];
        // 服务端采用边读边写的方式
        while ((realLen = in.read(temp)) != -1)
        {
            byteArray.write(temp, 0, realLen);
        }
        byte[] recvByte = byteArray.toByteArray();

        System.out.println("客户端接收消息成功,消息长度:" + recvByte.length);

    }
}

    方案二:  服务端不采用 “边读边写” 的方式，而是采用 “全部读完在全部发送” 的方式

    好处：这样，服务端和客户端的RecvQ队列就不会出现被填满的情况；

    坏处：不适用于大文件的传输，这样创建的缓冲区会比较大，很可能会造成数据的丢失；

/*
 * 服务端
 */
public class TestServer
{
    public static void main(String[] args) throws IOException
    {
        System.out.println("服务端启动......");
        ServerSocket server = new ServerSocket(8888);

        Socket client = server.accept();
        OutputStream output = client.getOutputStream();
        InputStream input = client.getInputStream();

        ByteArrayOutputStream byteArray = new ByteArrayOutputStream();
        byte[] temp = new byte[10];
        int realLen = 0;
        while ((realLen = input.read(temp)) != -1)
        {
            byteArray.write(temp, 0, realLen);
        }

        byte[] recvByte = byteArray.toByteArray();

        System.out.println("【服务端】正在发送数据......");
        output.write(recvByte);
        output.flush();
        System.out.println("【客户端】发送数据完毕!");

        client.close();
    }
}


/*
 * 客户端
 */
public class TestClient
{
    public static void main(String[] args) throws UnknownHostException,
            IOException
    {
        System.out.println("客户端启动......");
        final Socket client = new Socket(InetAddress.getLocalHost(), 8888);

        final OutputStream out = client.getOutputStream();
        InputStream in = client.getInputStream();
        final FileInputStream fileIn = new FileInputStream(new File(
                "D:\\杂乱\\桌面.jpg"));

        byte[] fileTemp = new byte[1024];
        int realFileLen = 0;

        while ((realFileLen = fileIn.read(fileTemp)) != -1)
        {
            System.out.println("【客户端】正在发送数据......");
            out.write(fileTemp, 0, realFileLen);
        }
        System.out.println("【客户端】发送数据完毕!");

        out.flush();
        client.shutdownOutput();

        ByteArrayOutputStream byteArray = new ByteArrayOutputStream();
        int realLen = 0;
        byte[] temp = new byte[10];
        while ((realLen = in.read(temp)) != -1)
        {
            byteArray.write(temp, 0, realLen);
        }
        byte[] recvByte = byteArray.toByteArray();

        System.out.println("客户端接收消息成功,消息长度:" + recvByte.length);

    }
}

每天进度一点点  —— 作者: 大饼

dabing69221
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java TCP IP Socket编程(中文版)
04-20
Java提供了强大的API来实现基于TCP/IP和UDP协议的Socket通信。 计算机网络是由多台计算机互联组成的系统，它们之间通过分组报文进行通信。网络通信协议是一种规则，定义了数据如何传输。TCP/IP是一种常用的协议族，...
socket是并发安全的吗？
最新发布
m0_71777195的博客
10-24 2381
多线程并发读/写同一个TCP socket是线程安全的，因为TCP socket的读/写操作都上锁了。虽然线程安全，但依然不建议你这么做，因为TCP本身是基于数据流的协议，一份完整的消息数据可能会分开多次去写/读，内核的锁只保证单次读/写socket是线程安全，锁的粒度并不覆盖整个完整消息。因此建议用一个线程去读/写TCP socket。多线程并发读/写同一个UDP socket也是线程安全的，因为UDP socket的读/写操作也都上锁了。
多线程同时写socket是否需要加锁（转）
01-24 3148
[打印] [订阅] [收藏] [推荐给朋友] [本帖文本页] yuangong 精灵
socket的write/send还是是否是线程安全?
热门推荐
windseeker2008的专栏
10-16 1万+
在多线程的网络服务器程序中， 对同一个客户端多线程同时发送数据是经常可能发生的事情， 也就是有可能会多 线程的对一个fd调用send/write, 那么这种操作是否需要加锁？并发写套接字是否导致系统缓冲区数据混乱呢？ 网上搜 了下，有人说可以写，有人说不能，linux man page也没有说明。 看来需要写程序测试。 写了个server的代码进行 测试。 10个线程同时对一个fd进行
【Java TCP/IP Socket】深入剖析socket——TCP通信中由于底层队列填满而造成的死锁问题（含代码）
兰亭风雨的专栏
11-16 9757
转载请注明出处：      基础准备     首先需要先了解下数据传输的底层实现机制，在http://blog.csdn.net/ns_code/article/details/15813809这篇博客中有详细的介绍，在上面的博客中，我们提到了SendQ和RecvQ缓冲队列，这两个缓冲区的容量在具体实现时会受一定的限制，虽然它们使用的实际内存大小会动态地增长和收缩，但还是需要一个硬性
JAVA printWriter中write()和println()区别
weixin_34414196的博客
04-02 875
PrintWriter 的Write()方法和println()方法有何细微的区别？ 最近学习JAVA网络编程，在服务器端和客户端产生一个Socket 后， 两边各自用getIputStream()和getOutputStream()方法,构造各自的输入输出流。 其中服务器端的Socket ss BufferedReader is=new BufferedReader(ne...
Java TCP IP Socket编程(中文版).pdf
03-06
在计算机网络领域，TCP/IP是一组用于互联网数据传输的协议，而Socket编程则是实现这些协议功能的一种编程技术。在Java语言中，Socket编程通过提供标准的API来实现网络通信，使得网络应用开发变得更加方便和高效。 ...
TCP-IP Socket编程
09-18
深入剖析章节进一步分析了TCP协议中的一些高级特性，如缓冲机制、死锁风险、性能考量，以及TCP套接字的生命周期管理。最后，介绍了NIO中的非阻塞连接、解调多路复用揭秘等内容。 整本书籍的知识点几乎涵盖了从基础...
Java CP/IP Socket编程
04-13
### Java CP/IP Socket编程 #### 第1章：简介 计算机网络的发展使得个人电脑不仅可以作为办公工具，还能成为娱乐中心和沟通平台。随着越来越多的人通过互联网进行互动，掌握网络编程技术变得尤为重要。本章旨在为...
java socket 重连_重新连接后，Java Socket连接“崩溃”
weixin_34226447的博客
02-20 631
我想在我的服务器和客户端之间创建套接字连接 . 在连接超时后，我的客户端应该重新连接 . 为此，我每隔3秒尝试连接一次插座 . 这很有效 . 但是，当我想开始阅读，但后来我得到错误“套接字关闭” . 可能是什么错误？这是错误日志(它在pastebin上，它在这里没有合成)：但是在我开始阅读之前，我尝试从套接字中获取IP，这有效......这是我的重新连接方法：public void reconne...
socket客户端异常关闭，服务端解决方案
weixin_33882452的博客
06-30 6500
2019独角兽企业重金招聘Python工程师标准>>> ...
Java Socket 长连接互发消息时发生的阻塞问题
小楼夜听雨的博客
04-17 1860
想实现一个功能，客户端发送一个消息，服务器接收到消息后回复客户端。 写好后发现并没有像预期的那样运作，一运行就阻塞，经过一番排查发现了问题。 问题分析 原来的代码如下： 服务端： public class ServerProDemo { public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(8081);
java golang tcp socket导致线上服务器出现大量close_wait的完整示例
Anteoy的博客
05-21 1894
tcp断开连接的四次挥手 先说说tcp的四次挥手，这里假定A端为主动发起关闭端，B端为被动接收关闭请求端。A把tcp的数据包中标识位FIN置为1，seq为一个随机数，发送这个包给B端，自己进入FIN_WAIT_1状态；B端收到了马上给A端回复ack（A端收到ack进入FIN_WAIT_2状态），然后自己进入CLOSE_WAIT状态。然后这个时候需要业务代码处理，把自己需要发给客户端的数据发送完，然...
java socket 卡住_java socket服务器端线程卡死
weixin_34359680的博客
02-16 940
packageSocket;importjava.io.DataInputStream;importjava.io.DataOutputStream;importjava.io.EOFException;importjava.io.IOException;importjava.net.BindException;importjava.ne...package Socket;import java....
TCP流量控制+拥塞控制
Peng__java的博客
04-09 2563
TCP流量控制 为了提高信道利用率，TCP采用连续ARQ协议。发送方维持一个发送窗口，凡位于发送窗口内的分组可以连续发送出去，而不需要等待对方确认。接收方一般采用累积确认，对按序到达的最后一个分组发送确认，表明到这个分组为止的所有分组都已经正确收到了。 实现方法：通过滑动窗口实现 TCP的两端都维持一个发送/接收缓存和接收/发送窗口。TCP的缓存是一个循环队列，其中发送窗口可以用3个指针表示。而发送窗口的大小受TCP数据报中窗口大小值的影响，TCP数据报中的窗口大小是接收端通知发送端其还可以接收多少数
TCP三次握手四次挥手以及死锁
菜鸡工坊
07-21 1529
三次握手过程 第一次握手：建立连接时，客户端发送SYN包（SYN=j）到服务器，并进入SYN_SENT状态，等待服务器确认；SYN：同步序列编号（Synchronize Sequence Numbers）。 第二次握手：服务器收到SYN包，必须确认客户的SYN（ACK=j+1），同时自己也发送一个SYN包（SYN=k），即SYN+ACK包，此时服务器进入SYN_RECV状态； 第三次握手：客户端...
TCP死锁、糊涂窗口综合症？
dongcheng_2015的博客
08-17 724
TCP流量控制 所谓流量控制就是让发送发送速率不要过快，让接收方来得及接收。利用滑动窗口机制就可以实施流量控制。通过运用TCP报文段中的窗口大小字段来控制，发送方的发送窗口不可以大于接收方发回的窗口大小。 流量控制引发的死锁 当发送者收到了一个窗口为0的应答，发送者便停止发送，等待接收者的下一个应答。但是如果这个窗口不为0的应答在传输过程丢失，发送者一直等待下去，而接收者以为发送者已经收到该应答，等待接收新数据，这样双方就相互等待，从而产生死锁。 持续计时器 为了避免流量控制引发的死锁，TCP使用了持
Java TCP/IP Socket编程指南：基础到高级实践
最后，教程深入剖析了TCP套接字的生命周期，包括连接建立、关闭连接以及可能出现的死锁和性能问题。此外，还涉及了TCP的缓存机制和多路复用技术。 这份教程是学习Java网络编程的宝贵资源，涵盖了从基础到高级的全面...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值