python利用多线程让http请求异步返回

嗨喽~大家好呀，这里是魔王呐 ❤ ~!

https://img-blog.csdnimg.cn/6b61cf3d76564ea3b93e2189e1f48d18.gif" alt="" />

python更多源码/资料/解答/教程等点击此处跳转文末名片免费获取

有时我们可能会碰到这样一种情况：

我们有一个功能，这个功能对外提供了一个http接口，

我们需要对这个http接口发起请求才能启动这个服务，

但是这个服务功能可能会执行很久，这样如果等功能执行结束再返回请求结果，

那这个请求可能就超时了

发起请求的客户端

 import requests
  
 req = requests.get("http://127.0.0.1:9898/register?username=aaa&pwd=232323")
 print(req.content)

服务端

# coding=utf-8
import flask
from flask import jsonify
from flask import request

from gevent import pywsgi

import sys
reload(sys)
import time
sys.setdefaultencoding('utf-8')

server = flask.Flask(__name__)
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：926207505
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
@server.route('/register', methods=['get', 'post'])
def registerPost():
    # post请求获取请求的参数，返回结果类型是str
    username = request.values.get('username')
    pwd = request.values.get('pwd')
    app_id = request.values.get('app_id')
    dowork(app_id)
    # confirmpwd = request.values.get('confirmpwd')
    if username and pwd:  # 判断输入的用户名、密码、确认密码都不为空
        return ("用户名为：%s, 密码为：%s" % (username, pwd))
    else:
        return jsonify({"code": 504, "msg": "必填项不能为空"})


if __name__ == '__main__':
    # port可以指定端口，默认端口是5000
    # host默认是127.0.0.1,写成0.0.0.0的话，其他人可以访问，代表监听多块网卡上面，
    # server.run(debug=True, port=9898, host='0.0.0.0')
    server = pywsgi.WSGIServer(('0.0.0.0', 9898), server)
    server.serve_forever()

这个就是一个典型的同步返回结果，

发起请求后，必须等 dowork() 功能执行完之后才能返回请求结果，

如果 dowork() 执行时间较长，则会导致客户端请求超时

这时我们可能就需要一个异步的http接口，收到客户端的请求后，马上返回一个请求结果，然后再慢慢的执行要执行的任务，这个过程怎么实现呢？

我的做法是通过多线程来实现，

在服务端的响应函数中，每次收到一个请求，获取请求中携带的参数，

然后用这些参数创建一个会执行我们功能服务的线程，

最后返回请求结果，这样客户端可以很快获取到请求结果，从而不会让客户端请求超时

下面是加入了线程的服务端的响应函数

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：926207505
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import flask
from flask import jsonify
from flask import request

from gevent import pywsgi

import sys
reload(sys)
import time
sys.setdefaultencoding('utf-8')

server = flask.Flask(__name__)

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter, app_id):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
        self.app_id = app_id
    def run(self):
        print ("开始线程：" + self.name)
        print_time(self.name, self.counter, 1, self.app_id)
        print ("退出线程：" + self.name)

def print_time(threadName, delay, counter, app_id):
    while counter:
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        dowork(app_id)
        counter -= 1

@server.route('/register', methods=['get', 'post'])
def registerPost():
    # post请求获取请求的参数，返回结果类型是str
    username = request.values.get('username')
    pwd = request.values.get('pwd')
    app_id = request.values.get('app_id')

    # 创建新线程
    thread1 = myThread(1, "Thread-1", 1, app_id)
    # 开启新线程
    thread1.start()

    # confirmpwd = request.values.get('confirmpwd')
    if username and pwd:  # 判断输入的用户名、密码、确认密码都不为空
        return ("用户名为：%s, 密码为：%s" % (username, pwd))
    else:
        return jsonify({"code": 504, "msg": "必填项不能为空"})


if __name__ == '__main__':
    # port可以指定端口，默认端口是5000
    # host默认是127.0.0.1,写成0.0.0.0的话，其他人可以访问，代表监听多块网卡上面，
    # server.run(debug=True, port=9898, host='0.0.0.0')
    server = pywsgi.WSGIServer(('0.0.0.0', 9898), server)
    server.serve_forever()

因为线程的run()方法和start()方法是不能传递参数的，

所以如果我们需要从请求中获取参数然后传递给要执行的功能的话，

可以在线程的构造方法的参数中加上我们需要传递的参数，

这样在run()方法内部我们就能动态获得请求中传递的参数了

下面是菜鸟教程里面的多线程模板

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：926207505
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import threading
import time

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print ("开启线程： " + self.name)
        # 获取锁，用于线程同步
        threadLock.acquire()
        print_time(self.name, self.counter, 3)
        # 释放锁，开启下一个线程
        threadLock.release()

def print_time(threadName, delay, counter):
    while counter:
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

threadLock = threading.Lock()
threads = []

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()

# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)

# 等待所有线程完成
for t in threads:
    t.join()
print ("退出主线程")

执行以上程序，输出结果为：

开启线程： Thread-1
开启线程： Thread-2
Thread-1: Wed Apr  6 11:52:57 2016
Thread-1: Wed Apr  6 11:52:58 2016
Thread-1: Wed Apr  6 11:52:59 2016
Thread-2: Wed Apr  6 11:53:01 2016
Thread-2: Wed Apr  6 11:53:03 2016
Thread-2: Wed Apr  6 11:53:05 2016