我已经开始修改一个用python制作的示例，以通过TCP服务器流式传输计数器的输出。代码下方
import socket
import sys
import time
from thread import *
HOST = '' # Symbolic name meaning all available interfaces
PORT = 8888 # Arbitrary non-privileged port
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1)
print 'Socket created'
#Bind socket to local host and port
try:
s.bind((HOST, PORT))
except socket.error as msg:
print 'Bind failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1]
sys.exit()
print 'Socket bind complete'
#Start listening on socket
s.listen(10)
print 'Socket now listening'
#Function for handling connections. This will be used to create threads
def clientthread(conn):
#Sending message to connected client
#conn.send('Welcome to the server. Type something and hit entern') #send only takes string
#infinite loop so that function do not terminate and thread do not end.
count = 0
while True:
count = count + 1
#Receiving from client
#data = conn.recv(1024)
#reply = 'OK...' + data
#if not data:
# break
reply = str(count)+'n'
print reply
conn.send(reply)
time.sleep(1)
#came out of loop
conn.close()
#now keep talking with the client
while 1:
#wait to accept a connection - blocking call
conn, addr = s.accept()
print 'Connected with ' + addr[0] + ':' + str(addr[1])
#start new thread takes 1st argument as a function name to be run, second is the tuple of arguments to the function.
start_new_thread(clientthread ,(conn,))
s.close()
我想使用我的浏览器从远程 http 客户端获取计数器。我必须等待计数器达到至少 260 个计数才能在浏览器上看到它。在第一次突发 260 计数之后，所有内容在服务器端和客户端同步运行。我做了不同的尝试来减少发送的缓冲区大小，但每次开始时都会有很大的滞后。
默认情况下，浏览器需要一个大的响应，并且在获得最小数据量之前不会呈现： 以下链接讨论了分块编码中的此限制，这是一种以块形式发送数据的方法。
使用传输编码分块如何数据必须发送之前浏览器-s/16909228#16909228
因此，即使您拼凑出有效的 HTTP1.0 分块响应系列，此限制也将适用：浏览器具有有效的标头，并且会以块的形式接受您的数据，但仍然会延迟渲染任何内容，直到一堆通过。
问题是：你真的需要一个完整的网络浏览器作为客户端吗？有更简单的方法可以从TCP流中读取一些原始数据。你可以用python编写一个，或者使用例如netcat甚至旧的telnet客户端？问题解决了;-(
好吧，说它真的需要一个浏览器。比你必须做更多的工作。立即发送实时数据的一种标准 (W3C( 方法是称为服务器发送事件的机制。您发送了内容类型文本/事件流，然后逐行发送数据，前面是"data："：
def clientthread(conn):
conn.send("HTTP/1.1 200 OKrnContent-Type: text/event-streamrnrn");
count = 0
while True:
count = count + 1
conn.send("data: %drn" % (count))
print count
time.sleep(1)
conn.close()
目前有图书馆可以习惯性地做到这一点，等等，但我想展示它基本上是多么简单。
但是现在，您需要在客户端Javascript中提供一些EventSource来理解这一点，例如，每次收到新计数器时，将一些HTML元素设置为计数器值。
它并不止于此..您现在必须提供生成的HTML和脚本，如果它不在同一台服务器上，请确保设置各种与安全相关的标头，否则您的浏览器将忽略您的脚本。
此外，事情可能很快就会变得复杂，除非这是一项学术练习，否则您将不得不考虑稳健性、标准合规性、边缘情况等。我强烈建议使用更高级别的HTTP服务器实现，如HTTPServer和BaseHTTPRequestHandler，它们可以为您完成大部分此类工作。
此示例 (python3( 使用示例 EventSource 提供 html(at/(和带有计数器的 SSE 流(在/counter(：
import sys, time
from http.server import HTTPServer,BaseHTTPRequestHandler
from socketserver import ThreadingMixIn
from socket import error
html_and_js = """<html>
<head>
<meta charset="UTF-8">
<title>Counter SSE Client</title>
</head>
<body>
Count:<span id="counter">0</span>
<script>
"use strict";
var counter = document.getElementById('counter');
var event_source=new EventSource("/counter");
event_source.onmessage=function(msg) {
counter.innerHTML=msg.data;
};
</script>
</body>
</html>
"""
class SSECounterRequestHandler(BaseHTTPRequestHandler):
server_version = "DzulianisCounter/0.1"
def do_html(self):
self.send_header("Content-type", "text/html")
self.send_header("Access-Control-Allow-Origin", "*")
self.end_headers()
self.wfile.write(bytes(html_and_js,'UTF-8'))
def do_sse(self):
self.counter=0
self.send_header("Content-type", "text/event-stream")
self.send_header("Cache-Control", "no-cache")
self.end_headers()
self.running=True
while self.running:
try:
self.wfile.write(bytes('data: %drnrn' % (self.counter),'UTF-8'))
self.counter+=1
time.sleep(1)
except error:
self.running=False
def do_GET(self):
self.send_response(200)
if self.path=='/counter':
self.do_sse()
else:
self.do_html()
class SSECounterServer(ThreadingMixIn, HTTPServer):
def __init__(self,listen):
HTTPServer.__init__(self,listen,SSECounterRequestHandler)
if __name__=='__main__':
if len(sys.argv)==1:
listen_addr=''
listen_port=8888
elif len(sys.argv)==3:
listen_addr=sys.argv[1]
listen_port=int(sys.argv[2])
else:
print("Usage: dzulianiscounter.py [<listen_addr> <listen_port>]")
sys.exit(-1)
server=SSECounterServer((listen_addr,listen_port))
server.serve_forever()
这比例如让页面定期轮询某些 URL 或一直重新加载页面时要高效得多，并且响应时间更好：-(以您的速度(每秒 1 次(，这也会使 http 连接保持打开，避免连接开销，但会给操作系统的网络堆栈增加一些内存开销，如果您会同时获得许多用户，这可能会感觉到。
享受！
我创建了一个线程式HTTP服务器，可以在其中提供延迟作为输入
from http.server import HTTPServer, BaseHTTPRequestHandler
from socketserver import ThreadingMixIn
import threading , sys
from time import sleep
server_ip = '0.0.0.0'
server_port = int(sys.argv[1])
latency_time = float(sys.argv[2])
class Handler(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header('Content-Type',
'text/plain; charset=utf-8')
sleep(latency_time)
self.end_headers()
message = threading.currentThread().getName() + ", Latency time = " + str(latency_time)
self.wfile.write(message.encode('utf-8'))
self.wfile.write(b'n')
class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
"""Handle requests in a separate thread."""
if __name__ == '__main__':
server = ThreadedHTTPServer((server_ip, server_port), Handler)
print('Starting server, use <Ctrl-C> to stop')
server.serve_forever()
这就是我启动服务器的方式
$ python3 HTTPLatencyServer.py 3389 .3
Starting server, use <Ctrl-C> to stop
127.0.0.1 - - [29/Apr/2022 11:31:33] "GET / HTTP/1.1" 200 -
127.0.0.1 - - [29/Apr/2022 11:31:33] "GET / HTTP/1.1" 200 -
127.0.0.1 - - [29/Apr/2022 11:31:34] "GET / HTTP/1.1" 200 -
127.0.0.1 - - [29/Apr/2022 11:31:34] "GET / HTTP/1.1" 200 -
127.0.0.1 - - [29/Apr/2022 11:31:34] "GET / HTTP/1.1" 200 -
示例输出
$ curl localhost:3389
Thread-101, Latency time = 0.3