Question

我有一个龙卷风服务器运行MySQL for DB和Redis for cache。我正在使用Web套接字发送/接收数据。我的代码是这样的：

服务器

import logging
import os.path
import uuid
import sys
import json

import tornadis
import tormysql
import tornado.escape
import tornado.ioloop
import tornado.options
import tornado.web
import tornado.websocket
from tornado import gen
from tornado.concurrent import Future
from tornado.options import define, options

@gen.coroutine
def getFromDB(query):
    with (yield dbPool.Connection()) as conn:
        with conn.cursor() as cursor:
            yield cursor.execute(query)
            datas = cursor.fetchall()
            return datas
    return None

@gen.coroutine
def getFromCache(cmd):
    pipeline = tornadis.Pipeline()
    pipeline.stack_call(cmd)
    with (yield cachePool.connected_client()) as singleClient:
        redisResult = yield singleClient.call(pipeline)
        if isinstance(redisResult, tornadis.TornadisException):
            print("Redis exception: %s"%(redisResult))
        else:
            return redisResult

async def getData(dbQuery, cacheQuery):
    waitDict = {}
    if dbQuery:
        waitDict['db'] = getFromDB(dbQuery)
    if cacheQuery:
        waitDict['cache'] = getFromCache(cacheQuery)
    resultList = []
    if len(waitDict) > 0:
        await gen.multi(waitDict)
        if 'db' in waitDict:
            dbRes = waitDict['db'].result()
            if dbRes:
                for eachResult in dbRes:
                    changeRes = someFunct(eachResult) 
                    resultList.append(changeRes)
        if 'cache' in waitDict:
            cacheRes = waitDict['cache'].result()
            if cacheRes:
                for eachResult in cacheRes:
                    changeRes = someFunct(eachResult) 
                    resultList.append(changeRes)
    return resultList

class SocketHandler(tornado.websocket.WebSocketHandler):
    SUPPORTED_METHODS = ("GET")

    def open(self):
        print("Socket open:%s"%(self))

    def on_close(self):
        print("Socket closed:%s"%(self))

    async def on_message(self, inp):
        if requestForData:
            ret = await getData(dbQuery, cacheQuery)
            self.write_message(ret)

class Application(tornado.web.Application):
    def __init__(self):
        handlers = [
            (r"/sock", SocketHandler),
        ]

define("port", default=8000, help="run on the given port", type=int)
tornado.options.parse_command_line()
app = Application()
app.listen(options.port)
print("PORT:%s"%(options.port))
tornado.ioloop.IOLoop.current().start()

我正在使用tornadis表示Redis，tormysql表示MySQL 我在亚马逊linux实例m5.large上运行此设置，带有2个CPU记忆：8Gib。

客户端

我正在尝试使用网络套接字模拟流量。代码是这样的：

import sys
import json
import asyncio
import websockets

def getData():
    for i in range(100):
        async with websockets.connect(SOCKET_URL, extra_headers=extraHeaders) as websocket:
            for i an range(100):
                await websocket.send("get data")
                reply = await websocket.recv()
                print(reply)

asyncio.get_event_loop().run_until_complete(getData())

我正在运行客户端的多个实例服务器运行良好，但它只能处理25个连接。在25个连接之后，来自服务器的回复的延迟增加。我希望服务器回复得非常快。如何减少响应的延迟？那么代码中有什么问题吗？

MySQL和Redis的龙卷风性能问题

0 个答案: