python多线程完成模拟支付请求

import asyncio
import sys
from queue import Queue


sys.path.append("../")
from tool.__init__ import *
from tool.decorator_token import *
import time
from threading import Thread,Lock



class doWeChatNotify(BaseTest):
    def __init__(self):
        super().__init__()
        self.limit_num=100 #查询记录条数
        self.WeChatNotify_sql='''select  order_id,order_sn from fw_order where `status`=0 
                        and course_id=1569 ORDER BY create_time desc limit %d ;'''%(self.limit_num)
        self.fwh_test_api=fwh_test_api
        self.data = self.my_op.sql_operation_fwh(self.WeChatNotify_sql)
        self.fwh_order_dict = {}
        self.que = Queue()


    @token_fwh#验证token有效性
    def get_fwh_token_list(self):
        token_list=self.fwh_token.loadTokenList()
        return token_list

    @token_crm#验证token有    def get_crm_token_list(self)        token_list=self.token.loadTokenList()

        return token_list

    def testDoWeChatNotify(self):
        DoWeChatNotify_file='../tokenFileAndtxtFiles'+'/'+"DoWeChatNotify_asynchronousPay.txt"
        with open(DoWeChatNotify_file,'a',encoding='utf=-8') as file:
            str_first="order_id	"+"order_sn	
" #文件首行数据
            file.write(str_first)
        fwh_order_id_list, fwh_order_sn_list = [], []

        if  self.data!=():
            for a in self.data:
                fwh_order_id=a['order_id']
                fwh_order_sn=a['order_sn']
                self.fwh_order_dict[fwh_order_id]=fwh_order_sn

                with open(DoWeChatNotify_file,'a',encoding='utf-8') as file2:#文件写入
                    str_DoWeChatNotifyInfo=str(fwh_order_id)+'	'+str(fwh_order_sn)+'	
'
                    file2.flush() #清除缓冲区
                    file2.write(str_DoWeChatNotifyInfo)
                self.que.put(self.fwh_order_dict)#将数据添加至队列
        #关闭数据库连接
        # self.my_op.close_db_fwh()
        # self.my_op.close_db()
        return self.que.qsize()#返回队列数量


    def asynchronousPay(self,order_id,order_sn):
        count=1
        count_num=50
        token_list=self.get_fwh_token_list()
        if  (self.data!=()):
            headers_form_urlencoded['token']=token_list[0]
            url_wechat_success_huidiao=self.fwh_test_api+'/index/Order/doWeChatNotify'
            data_wechat_success_huidiao=self.data_to_str.requestDataToStr_firefoxAndChrome_fwh('''order_sn:{}
order_id:{}
meth_id:4
timestamp:157129653969
sign:0687b01b300b9e300d3996a9d2173f1380973e5a'''.format(order_sn,order_id))
            request_wechat_success_huidiao=requests.post(url=url_wechat_success_huidiao,headers=headers_form_urlencoded,data=data_wechat_success_huidiao)
            response_wechat_success_huidiao=request_wechat_success_huidiao.json()
            if '订单状态错误,非待支付订单' in response_wechat_success_huidiao['msg']:
                print(data_wechat_success_huidiao)
        else:
            print('待支付订单为空')

    def run_multithreading(self):#多线程
        threads = []#存放所有的线程
        nloops = list(range(self.testDoWeChatNotify()))#获取队列数量
        if len(nloops)>0:
            for i,k in zip(nloops,self.que.get().items()):#根据队列数量来创建线程
                t = Thread(target=self.asynchronousPay,args=(k[0],k[1]))
                threads.append(t)

            for s in nloops:  # 开始多线程
                threads[s].start()

            for j in nloops:  # 等待所有线程完成
                threads[j].join()

        else:
            print("队列数量为空")



if __name__=="__main__":
    start_time = time.time()  # 计算程序开始时间
    wechfy=doWeChatNotify()
    wechfy.run_multithreading()#多线程
    print('程序耗时{:.2f}'.format(time.time() - start_time))  # 计算程序总耗时

思路：
　　队列使用说明：
　　　　　　multiprocessing.Queue()#用于进程间通信，单主进程与子进程无法通信（使用进程池时尽量不要使用这个）
　　　　　　multiprocessing.Manager().Queue()#用于主子进程通信，通过进程池（pool）创建的进程可以数据共享
　　　　　　queue.Queue()#用于线程间通信，同一进程内的数据可以共享

　　1.从数据库里获取待支付的订单
　　2.将获取出来的数据添加至队列（queue.Queue()），并在函数中返回消息队列的长度
　　3.根据队列长度创建对应的线程数量
　　4.把创建的线程放在list
　　5.依次启动
　　6.最后等待主线程执行完结束，统计函数运行时长
总结：亲测运行时间还是会快很多，单线程支付100个订单四十几秒的样子，多线程运行不用join2.x秒，用join八秒的样子，还有很大的优化空间，因为运行时会创建100个线程
求大佬指教，最近想用多线程或者多进程做并发测试

ps： 最近看了下文章，发现python中是这么定义多线程与多进程的使用场景的，cpu密集型（复杂计算）程序适合多进程处理，io密集型（写文件、网络请求等）程序适合多线程处理