我有一个龙卷风服务器，它将创建与客户端的web套接字连接。每当客户机请求一些数据时，我都需要从redis或mysql数据库获取数据。除此之外，我还需要收听来自tornado服务器的广播，接收网络数据包并将它们发送到订阅了数据的客户端。向客户端发送广播数据包取决于数据包中的令牌。如果客户订阅了令牌，我们应该将数据包发送给他。
请求速率：
5000个活动web套接字连接（可以增加）
每秒每个套接字连接1-db请求，因此每秒总共有5000 db请求
每秒每个套接字连接有1个redis请求，因此每秒总共有5000个redis请求。
在广播我应该听1000包/秒，并检查是否有任何用户订阅了令牌。
我知道redis是单线程的，并且是异步工作的（如果我错了，请纠正我）。对于mysql db，我使用的异步驱动程序是“tormysql”（我对db的大多数调用都是select查询，没有复杂的db操作）。
我的问题是：
对mysql db的调用是否会阻塞？如果它们阻止了调用，我是否可以为db查询运行不同的线程/进程？
龙卷风有没有可能在广播里丢包？
我可以在我的资源前面有一个负载均衡器，并为它们提供服务器，但是我是否可以使用一个带有2核8 gb ram的cpu？
更新1：
我为mysql编写了一个代码：
服务器.py

import logging
import tornado.escape
import tornado.ioloop
import tornado.options
import tornado.web
import tornado.websocket
import os.path
import uuid
import sys
from tornado import gen

from tornado.options import define, options

import tormysql ## MySQL async driver
pool = tormysql.ConnectionPool(
    max_connections = 20, #max open connections
    idle_seconds = 7200, #conntion idle timeout time, 0 is not timeout
    wait_connection_timeout = 3, #wait connection timeout
    host = "127.0.0.1",
    user = "test",
    passwd = "",
    db = "testdb",
    charset = "utf8"
)

define("port", default=8000, help="run on the given port", type=int)

class Application(tornado.web.Application):
    def __init__(self):
        handlers = [
            (r"/", MainHandler),
            (r"/dataSock", ChatSocketHandler),
        ]
        settings = dict(
            cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__",
            template_path=os.path.join(os.path.dirname(__file__), "templates"),
            static_path=os.path.join(os.path.dirname(__file__), "static"),
            xsrf_cookies=True,
        )
        super(Application, self).__init__(handlers,**settings)

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.render("indexWS.html")

class ChatSocketHandler(tornado.websocket.WebSocketHandler):
    openConnCount = 0
    def get_compression_options(self):
        # Non-None enables compression with default options.
        return {}

    def open(self):
        # print("Socket open:%s"%(self))
        ChatSocketHandler.openConnCount += 1
        None
    def on_close(self):
        # print("Socket closed:%s"%(self))
        ChatSocketHandler.openConnCount -= 1
        None

    async def on_message(self, message):
        logging.info("open conn count %r", ChatSocketHandler.openConnCount)
        returnDB = await getDataFromDB()
        self.write_message("server got this from you:%s"%(str(returnDB)))

@gen.coroutine
def getDataFromDB():
    with (yield pool.Connection()) as conn:
        try:
            with conn.cursor() as cursor:
                yield cursor.execute("SHOW TABLES;")
                # print(cursor.fetchall())
        except:
            yield conn.rollback()
        else:
            yield conn.commit()

        with conn.cursor() as cursor:
            yield cursor.execute("SELECT * FROM theme;")
            datas = cursor.fetchall()

    return datas

    # yield pool.close()
def main():
    tornado.options.parse_command_line()
    app = Application()
    # print "options:", options
    # sys.exit()
    app.listen(options.port)
    print("PORT:%s"%(options.port))
    tornado.ioloop.IOLoop.current().start()

if __name__ == "__main__":
    main()

现在当我用这个测试代码时：
客户端.py

import asyncio
import websockets

async def hello(i):
    async with websockets.connect('ws://localhost:8000/dataSock') as websocket:
        name = 'A'#input("What's your name? ")
        print("******************************%s******************************"%(i))
        for j in range(100):
            await websocket.send(name)
            # print("> {}".format(name))

            greeting = await websocket.recv()
            print("{}: {}".format(i, len(greeting)))
            asyncio.sleep(10)

async def start():
    for i in range(10):
        await hello(i)
    print("end")
    asyncio.sleep(20)
asyncio.get_event_loop().run_until_complete(start())

# asyncio.get_event_loop().run_forever()

如果我只运行一个代码示例，那么一切都正常。当我将客户机的数量增加到70（客户机的70个示例）时，我得到的响应会有延迟。
第二题解释：
tornado服务器必须监听某个端口，在该端口中我将接收网络数据包，如果订阅了这些数据包，我必须将其发送给客户端。那么，这些数据包是否有可能被丢弃呢？