Socket 编程遇到的同步问题

最新推荐文章于 2021-08-04 23:26:40 发布
最新推荐文章于 2021-08-04 23:26:40 发布
阅读量400 收藏 4
点赞数
文章标签： python socket 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42299079/article/details/118228346
版权

Socket 编程遇到的同步问题

背景

baseline Fedavg复现：

图一：fedavg流程图
预期实现功能：
同步客户机和服务器之间的交流，实现客户本地计算后服务器统一收集客户的模型参数，然后再由服务器统一分发平均后的参数。

代码：

1.server
# 在循环外监听TCP socket
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("127.0.0.1", 7788))
server.listen(128)

for t in range(epochs):
    print(f"Epoch {t + 1}\n-------------------------------")

    # theta清零
    for key in theta.keys():
        theta[key] -= theta[key]

    # local_weights 存放 local_model
    local_weights = []

    # 建立TCP连接
    client_list = []
    print(f"{time.ctime()}   wait for connection")
    client01, addr01 = server.accept()
    print(f"{time.ctime()}: one client:{client01,addr01} is connected")
    client02, addr02 = server.accept()
    print(f"{time.ctime()}: one client:{client02,addr02} is connected")
    client_list.append(client01)
    client_list.append(client02)
    print(f"{time.ctime()}   all client connect")

    # 接收来自各个选中客户端的更新模型
    for i in range(0, m):
        print(f"{time.ctime()}   client {i} start uploading")
        total_data = b''
        while True:
            print(f"{time.ctime()}   start downloading...")
            data = client_list[i].recv(1024)
            print(f"{time.ctime()}   finish one loop...")
            if len(data)==0: break
            total_data += data
        print(f"{time.ctime()}   out of loop")
        # 断开连接
        client_list[i].close()
        local_weights.append(pickle.loads(total_data))
    print(f"{time.ctime()}   download success...")

    # 平均得到共识变量theta
    theta = average_weights(local_weights)

    # 将更新后的共识变量theta发送给所有节点
    if t < 9:
        # 建立TCP连接
        client_list = []
        client01, addr01 = server.accept()
        print(f"{time.ctime()}: one client:{client01,addr01} is connected")
        client02, addr02 = server.accept()
        print(f"{time.ctime()}: one client:{client02,addr02} is connected")
        client_list.append(client01)
        client_list.append(client02)
        print("connect success...")
        for i in range(0, m):
            print("start2......")
            client_list[i].sendall(pickle.dumps(theta))
            print("send theta succees!")
            # 断开连接
            client_list[i].close()

    # server不进行训练
    # upload_msg, model, alpha = train_loop(train_dataloader, model, loss_fn, optimizer, alpha, theta)

    # 服务器测试当前loss和精度
    model.load_state_dict(theta)
    test_loop(test_dataloader, model, loss_fn)

server.close()
2.client
for t in range(epochs):
    print(f"{time.ctime()}   Epoch {t + 1}\n-------------------------------")

    if t:
        # 接收来自server更新的theta
        # 创建TCP socket
        client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 连接server
        print(f"{time.ctime()}:   a client socket is created")
        client.connect(server)
        print(f"{time.ctime()}:   connect success......")
        print(f"socket info: {client.getsockname()}")

        # 接受数据
        total_data = b''
        while True:
            print(f"{time.ctime()}   start downloading...")
            data = client.recv(1024)
            print(f"{time.ctime()}   finish one loop...")
            total_data += data
            if len(data)==0: break
        theta = pickle.loads(total_data)
        print("downloading success......")
        client.close()

    # 本地训练，更新参数
    upload_msg, model, alpha = train_loop(train_dataloader, model, loss_fn, optimizer, alpha, theta)

    # 上传upload_msg给服务器
    # 创建TCP socket
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    print(f"one client {client} is created")
    client.connect(server)
    print(f"{time.ctime()}:   connect success......")
    print(f"socket info: {client.getsockname()}")
    print("uploading...")
    client.sendall(pickle.dumps(upload_msg))
    print(f"{time.ctime()}   upload success")
    client.close()

    # client可以不需要test
    test_loop(test_dataloader, model, loss_fn)

print("Done!")

日志：

server卡在了收集第二个客户本地参数的循环中：
在这里插入图片描述
client0提示上传成功，等待服务器发送参数
在这里插入图片描述
client1也提示发送成功，等待服务器分发更新的参数
在这里插入图片描述
这样也就陷入了死锁之中，即服务器等待客户1上传参数，而两个客户均等待服务器分发参数。
通过打印每次连接socket的地址也就是socket.getsocketname()，发现问题的原因是两个客户的训练速度不同步，导致服务器开放的两个accept第一次被客户0拿去上传本地参数，第二个又被客户0拿去准备接收更新参数。而客户1虽然没有拿到accept但是connect成功后正常发送参数，然后再次与服务器相连，进入等待传参的阻塞状态。

socket基本command特性

socket的基本command包括六个:

  1. socket.listen()
  2. socket.accept()
  3. socket.connect()
  4. socket.send()/socket.sendall()
  5. socket.recv()
  6. socket.bind()

一般的server-client模式下先由服务器建立一个socket并且和固定ip的固定端口相绑定：

import socket
server=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((''127.0.0.1",1500))

接着server开始侦听连接：

server.listen(10)

参数代表等候连接的队列最大容量，于此同时，客户创建socket并且连接服务器端口，listen的缓冲队列就会加入连接请求。

client=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((''127.0.0.1",1500)) ##需要指定连接的ip以及端口

而服务器若想与客户建立连接还需要accept客户机的连接请求，也就是socket.accept(),函数返回创立连接的专用socket(conn)以及客户的地址(addr)

conn,addr=server.accept()

如果客户机send()二进制数据，服务器的conn的缓冲区就会接收到相应的数据。

## client:
client.send(b'hello world!')

## server:
data=conn.recv(1024)

那么打印data就可以得到"hello world!"了。

socket基本command的阻塞与返回

要想理解baseline网络编程出现的问题不仅得弄明白socket编程的这些基础指令的功能，还得明白这些指令什么时候阻塞，什么时候返回。
非阻塞指令：

  1. socket.bind()
  2. socket.listen()
  3. socket.send()/sendall()
  4. socket.connect()

阻塞指令：

  1. socket.accept()
  2. socket.recv()

需要理解listen(size)创建了一个连接池，当客户发送connect请求，请求直接入队。而当listen队列里无请求，服务器的accept()指令将会阻塞直到得到一个请求连接。
同样的，当客户发送数据给服务器时(client.send(data)),数据也是立即被发送的，并不等server是否接收。而当server.recv(size)数据时，只有下述三种情况下会返回：

  1. recv(size)的数据超过size大小
  2. 缓冲区收到数据并且一段时间后(测试大约0.1s)无新数据到达
  3. 客户断开连接.
    因此在baseline中，因为服务器不会发送数据给客户，客户将一直阻塞在接收数据的状态中。

所以可见本问题的核心在于协调不同客户的连接请求的次序，让服务器清楚的知道socket连接的对面是哪个客户机，而不是随机让客户争抢连接请求次序。

解决办法

1.让客户停等(stop-wait)

将初始baseline的客户本地训练完即发送模型参数改为本地训练完等待服务器指令，从而将沟通的主动权还给服务器。
在这里插入图片描述
让服务器挨个询问并接收客户的本地训练参数。例如服务器一开始先问客户机0是否训练完毕，发送完请求后开始等待回应，这样服务器开始进入等待状态。当客户机0本地训练完后接收服务器的指令，发现服务器询问状态，客户机0随即返回已经准备好，并立刻发送本地数据，然后进入下一步指令的等待状态。而服务器接收到客户机0返回的准备好的反馈后，开始循环接收本地参数，直到接收参数大小不满最大size,说明是最后一个参数包。接着继续询问其他客户是否准备好。
当收集完所有客户的反馈参数后，服务器挨个给客户机发送接收更新参数的指令，并发送更新参数。然后进入下一轮更新。
通过这样的逻辑结构实现了客户机和服务器的同步。但是缺点在于效率比较低下。

2.引入多线程

自然而然的，可以想到将第一步等待询问优化为多线程编程，实现服务器并行对多客户指令沟通。

server:
import socket
import time
import threading
import numpy as np
import sys
import csv
num_devices=2
num_epoch=5
flags=np.zeros(num_devices).tolist()
def download(conn,addr,i):
    conn.send(b'upload theta!')
    file = open("communication.txt", "a")
    writer = csv.writer(file)
    writer.writerow([time.ctime(),server.getsockname(),f'ask client {addr} to upload theta'])
    file.close()
    print(f'ask client {addr} to upload theta')
    answer=conn.recv(1024)
    print(f'client {addr} reply {answer}')
    total_data=b''
    while True:
        data = conn.recv(1024)
        total_data += data
        if len(data)<1024: break ##更改判断条件
    local_weights.append(pickle.loads(total_data))
    file = open("communication.txt", "a")
    writer = csv.writer(file)
    writer.writerow([time.ctime(), server.getsockname(),f"finish collecting theta from client {addr}"])
    file.close()
    print(f"client {addr} finished uploading theta")
    flags[i]=1
    sys.exit()
server=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1',1500))
server.listen(10)
conn=[]
for i in range(num_devices):
    connection,addr=server.accept()
    file = open("communication.txt", "a")
    writer = csv.writer(file)
    writer.writerow([time.ctime(), server.getsockname(),f' client {addr} is accepted'])
    file.close()
    print(f'{time.ctime()}: client {addr} is accepted')
    conn.append([connection,addr])
print("all clients are connected")
for epoch in range(num_epoch):
    print(f'Epoch {epoch}---------------------------')
    ##downloading theta
    flags=np.zeros(num_devices).tolist()
    for i in range(num_devices):
        t=threading.Thread(target=download,args=(conn[i][0],conn[i][1],i))
        t.start()
    
    ##checking flags
    while True:
        count=0
        for i in flags:
            if i==1:count=count+1
        if count==num_devices: break
    file = open("communication.txt", "a")
    writer = csv.writer(file)
    writer.writerow([time.ctime(), server.getsockname(),'finish collecting'])
    file.close()
    print("finish collecting")
    ##计算
    theta = average_weights(local_weights)
    file = open("communication.txt", "a")
    writer = csv.writer(file)
    writer.writerow([time.ctime(), server.getsockname(),'finished averaging!'])
    file.close()
    print("finished averaging!")
    ##delivering consensus theta
    file = open("communication.txt", "a")
    writer = csv.writer(file)
    writer.writerow([time.ctime(), server.getsockname(),f'Epoch {epoch}: start delivering'])
    file.close()
    print(f"Epoch {epoch}: start delivering")
    for i in range(num_devices):
        file = open("communication.txt", "a")
        writer = csv.writer(file)
        writer.writerow([time.ctime(), server.getsockname(),f'ask client {conn[i][1]} to download consensus theta'])
        file.close()
        conn[i][0].send(b'download theta!')
        time.sleep(1)
        conn[i][0].sendall(pickle.dumps(theta))
        time.sleep(1)
    file = open("communication.txt", "a")
    writer = csv.writer(file)
    writer.writerow([time.ctime(), server.getsockname(),f'Epoch {epoch}: finish delivering'])
    file.close()
    print(f"Epoch {epoch}: finish delivering")
client:
import time
import socket
client=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1',1500))
print("connection established!")
num_epoch=5
for i in range(num_epoch):
    print(f"Epoch {i}: start calculation")
    #calculate locally
    upload_msg, model, alpha = train_loop(train_dataloader, model, loss_fn, optimizer, alpha, theta)
    test_loop(test_dataloader, model, loss_fn)
    print("calculation finished!")
    
    ##upload waiting
    while True:
        data=client.recv(1024)
        if data==b'upload theta!':
            print(f"Epoch {i}:server required uploading theta")
            client.send(b'Ready to upload theta')
            time.sleep(1)
            client.sendall(pickle.dumps(upload_msg))
            print("send all theta")
            
        elif data==b'download theta!':
            print(f"Epoch {i}:download theta from server")
            total_data = b''
            while True:
                data = client.recv(1024)
                total_data += data
                if len(data)<1024: break
            break
        else:
            continue
print("finished!")
client.close()

实现了交流的优化

Forrest Lea
关注
Socket客户端，服务端同步异步实现
11-04
Socket客户端，服务端同步异步实现，源码，服务端异步，客户端异步；服务端同步，客户端同步；服务端异步，客户端同步
同步编程异步编程php,socket服务的模型下的编程方式(同步和异步)
weixin_36197581的博客
03-18 108
前面我们花了一段时间来搭建高性能的socket服务，可以同时处理大量的连接，但这是在没有具体业务的情况下。如果我们启用了一个单进程的server,但里面的一个业务耗时1秒，那么在这1秒内是阻塞的，后续的请求会等待,如果并发三个请求，那么三个请求的执行时间会分别昌1秒,2秒,3秒.提高并发的方法有以下几种:1:多启动进程，提高并发数2:优化业务，减少耗时间相当于减少阻塞时间，提高并发数3:异步编程，...
C# iocp通讯客户端只能发送数据，无法接收服务端发送的数据
xwnxwn的专栏
07-30 2415
using System; using System.IO; using System.ComponentModel; using System.Collections; using System.Diagnostics; using System.Net; using System.Net.Sockets; using System.Threading; using System.Text;
socket编程常见问题总结
天泉证道
11-07 1397
首先申明，这个是我很久之前摘抄到我电脑的，已经忘了具体从哪里弄的了，如有侵权，留言立删。 总结1： TCP socket 三次握手，四次挥手发生在什么时候？ 三次握手：客户端connect()函数请求连接的时候，三次握手成功之后调用accept()函数； 四次挥手：客户端发送完数据，close()函数关闭socket描述符的时候。 总结2： TCP socket编程中为什么使用这四个函...
阿里云部署netty-socketio遇到的坑
zhuzj12345的博客
02-23 2747
在本地部署用localhost,线上部署不能有Hostname,否则连接会一直失败 package com.ydkj.netty.server; import com.corundumstudio.socketio.Configuration; import com.corundumstudio.socketio.SocketIOClient; import com.corundumstud...
简单的socket编程
02-17
在移动开发中，socket编程常用于实现设备之间的通信，例如游戏的实时对战、设备同步或者远程控制应用等。Xcode是一个强大的iOS和macOS开发工具，项目文件`SocketTest.xcodeproj`很可能包含了示例代码，帮助开发者...
Java Socket编程简介_动力节点Java学院整理
08-30
总结来说，Java Socket编程是实现网络应用程序间通信的基础，主要涉及`ServerSocket`和`Socket`对象的使用。服务端通过`ServerSocket`监听指定端口，接收来自客户端的`Socket`连接请求，然后通过`Socket`进行通信。...
socket同步和异步编程实例(C#)
08-26
此外，异常处理是Socket编程的重要部分，因为网络通信可能会遇到各种问题，如连接断开、超时或数据格式错误等。`MSDN`的示例通常会包含适当的异常处理机制，以确保程序在遇到问题时能够优雅地恢复或关闭连接。 在...
长连接与短连接
junJZ_2008的专栏
10-23 855
长连接与短连接 所谓长连接，指在一个TCP连接上可以连续发送多个数据包，在TCP连接保持期间，如果没有数据包发送，需要双方发检测包以维持此连接，一般需要自己做在线维持。 短连接是指通信双方有数据交互时，就建立一个TCP连接，数据发送完成后，则断开此TCP连接，一般银行都使用短连接。  比如http的，只是连接、请求、关闭，过程时间较短,服务器若是一段时间内没有收到请求即可关闭连接。 其实长连接是...
c语言socket多线程模版,socket 多线程写解决方法
weixin_29234239的博客
05-19 848
socket 多线程写现在项目有个场景：从一个socket来的数据需要分发到多个逻辑线程处理；多个逻辑线程需要通过同一个socket发送数据，是需要封装一个同步写比如:intSyncWrite(char*pData,intlength){CBuffer*pBuffer=newCBuffer(pData,length);Lockclock;socket.send(pBuffer...
socketIo 全平台解决方案！！！ 后台是java,netty框架
chukuang1705的博客
11-27 488
<dependency> <groupId>com.corundumstudio.socketio</groupId> <artifactId>netty-socketio</artifactId> &l...
socket编程中recv函数接收到的字符串乱码解决方法
weixin_44807846的博客
08-04 8172
for(int i = 0; i < 2; i++){ recv_len = recv(s_server, recv_buf, 40, 0); if (recv_len < 0) { cout << "接受失败！" << endl; break; } else { cout << "服务端信息:" << recv_buf << endl; } cin >> send_buf; send_len =
Socket 中级篇（三）C# Socket的同步连接和异步连接区别：大规模客服端连接、少开线程、高性能
xpj8888的博客
07-22 2977
目录 参考： 一、简介 1.1、提出问题 1.2、问题分析 1.3、拓展Socket的同步连接与异步连接 1.3.1、什么是同步连接、异步连接 二、Socket同步通信实现 2.1、Server 2.2、Client 三、Socket异步通信实现 参考： https://www.debugease.com/csharp/1114414.html 一、简介 1.1、提出...
socket 服务端发送数据大于客户端接收速度_python+socket+DES实现加密通信
weixin_39670849的博客
12-07 328
一、概述Socket编程，将DES加密算法应用到网络通信，使用RSA算法自动分配密钥，设计好界面，可验证自动生成的密钥和加解密的正确结果。二、功能需求客户端和服务器建立连接后，客户端生成一个随机DES密钥服务器端生成一个随机的RSA公私钥对，并将公钥发给客户端客户端收到公钥后加密DES密钥，发给服务器，服务器用私钥解密客户端和服务器使用DES密钥通信，进行聊天会话三、总体设计3.1 设计思想利用S...
关于socket的多线程操作。
Shallway
12-15 4267
无意间想到的问题，随便记下，免得以后忘了。。 就是一般多线程操作socket是线程安全的，但是很显然，会导致数据包错乱。 悲剧的是，我的netway虽然是用线程池操作消息队列。但是我在消息里指定发送端套接字，如果某2个消息包含同样的目的套接字，而恰好这2个消息又同时被处理，那肯定就数据错误了。。 现在想想，如果非要多线程处理同一个套接字： 对于recv，可以对接收的数据块编号，最后按序排列
C++ socket连接的知识点
hua_hengixn的博客
12-30 374
1、socket同步与异步 同步与异步主要针对客户端，阻塞与非阻塞主要针对服务器端。 1. 同步，就是我调用一个功能，该功能没有结束前，我死等结果。 2. 异步，就是我调用一个功能，不需要知道该功能结果，该功能有结果后通知我（回调通知） 3. 阻塞， 就是调用我（函数），我（函数）没有接收完数据或者没有得到结果之前，我不会返回。 4. 非阻塞， 就是调用我（函数），我（函数）立即返回，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值