python自动化测试学习笔记-8多线程

线程模块

python的多线程只能利用cpu的一个核心，一个核心同时只能运行一个任务那么为什么你使用多线程的时候，它的确是比单线程快
答:如果是一个计算为主的程序（专业一点称为CPU密集型程序），这一点确实是比较吃亏的，每个线程运行一遍，就相当于单线程再跑，甚至比单线程还要慢——CPU切换线程的上下文也是要有开销的。
但是，如果是一个磁盘或网络为主的程序（IO密集型）就不同了。一个线程处在IO等待的时候，另一个线程还可以在CPU里面跑，有时候CPU闲着没事干，所有的线程都在等着IO，这时候他们就是同时的了,
而单线程的话此时还是在一个一个等待的。我们都知道IO的速度比起CPU来是慢到令人发指的，python的多线程就在这时候发挥作用了。比方说多线程网络传输，多线程往不同的目录写文件，等等。

Python通过两个标准库thread和threading提供对线程的支持。thread提供了低级别的、原始的线程以及一个简单的锁。

threading 模块提供的其他方法：

• threading.currentThread(): 返回当前的线程变量。
• threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
• threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:

• run(): 用以表示线程活动的方法。
• start():启动线程活动。
• join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
• isAlive(): 返回线程是否活动的。
• getName(): 返回线程名。
• setName(): 设置线程名。

定义一个线程：

def learn(name,age):
    print('my name is %s ,%s years old ，i like swim '%(name,age))
#定义一个线程，指定运行哪个程序，一个线程后args后边跟逗号
t=threading.Thread(target=learn,args=('wang',34))
t.start()

如果要启动多个线程，可以使用循环实现：

users=[
    ['wang',34,'swim'],
    ['li',23,'travel'],
    ['zhao',14,'reading']

]
def learn(name,age,skill):
    time.sleep(10)
    print('my name is %s ,%s years old ，i like %s '%(name,age,skill))
#定义一个线程，指定运行哪个程序，一个线程后args后边跟逗号
for user in users:
    t=threading.Thread(target=learn,args=(user[0],user[1],user[2]))
    t.start()

print('主线程结束')

查看执行结果：

主线程结束
my name is wang ,34 years old ，i like swim
my name is li ,23 years old ，i like travel
my name is zhao ,14 years old ，i like reading

Python中，默认情况下，如果不加join语句，那么主线程不会等到当前线程结束才结束，但却不会立即杀死该线程

我们看到上边的代码，执行后，先结束了主线程，但子线程还在执行中，10秒以后子线程结束，为了避免这种情况，我们可以使用join来是子线程进行等待，join是阻塞当前线程，即使得在当前线程结束时，不会退出。

users=[
    ['wang',34,'swim'],
    ['li',23,'travel'],
    ['zhao',14,'reading']

]
def learn(name,age,skill):
    time.sleep(5)
    print('my name is %s ,%s years old ，i like %s '%(name,age,skill))
#定义一个线程，指定运行哪个程序，一个线程后args后边跟逗号
threads=[]
for user in users:
    t=threading.Thread(target=learn,args=(user[0],user[1],user[2]))
    t.start()
    threads.append(t)
for t in threads:
    t.join()#主线程等待子线程结束

print('主线程结束')

执行查看结果：

my name is li ,23 years old ，i like travel
my name is zhao ,14 years old ，i like reading
my name is wang ,34 years old ，i like swim
主线程结束

守护线程：setDaemon(True)，设置之后如果不加join语句，当主线程结束后，会杀死子线程

users=[
    ['wang',34,'swim'],
    ['li',23,'travel'],
    ['zhao',14,'reading']

]
def learn(name,age,skill):
    time.sleep(5)
    print('my name is %s ,%s years old ，i like %s '%(name,age,skill))
#定义一个线程，指定运行哪个程序，一个线程后args后边跟逗号
threads=[]
for user in users:
    t=threading.Thread(target=learn,args=(user[0],user[1],user[2]))
    t.setDaemon(True)
    t.start()

print('主线程结束')

执行查看结果：
主线程结束

我们看到，不加setDaemon(True)的时候，主线程结束之后，子线程没有立即结束，是在执行完之后结束的。添加setDaemon(True)，主线程结束后子线程立即结束。

线程池：我们上面用到的循环的方式开启了多个线程，python中可以使用第三方的包threadpool线程池包，实现处理线程问题

安装：pip install threadpool

（1）引入threadpool模块

    （2）定义线程函数

    （3）创建线程 池threadpool.ThreadPool()

    （4）创建需要线程池处理的任务即threadpool.makeRequests()

    （5）将创建的多个任务put到线程池中,threadpool.putRequest

    （6）等到所有任务处理完毕theadpool.wait()

import threadpool
#定义线程函数
def say(num):
    print(num)

#创建线程池
pool=threadpool.ThreadPool(3)
#生成线程池要执行的东西，makeRequests,传入数量，自动找出每个线程要执行的数据
reqs=threadpool.makeRequests(say,list(range(11)))
#创建多个任务put到线程池中
for req in reqs:
    pool.putRequest(req)
pool.wait()

执行：

0
1
2
3
4
5
6
7
8
9
10

现在我们可以来封装一个线程池了：

import threadpool

class MyPool(object):
    def __init__(self,func,poolsize=10,data=None):
        self.func=func
        self.poolsize=poolsize
        self.data=data
    def pool(self):
        pool=threadpool.ThreadPool(self.poolsize)
        reqs=threadpool.makeRequests(self.func,self.data)
        [pool.putRequest(req) for req in reqs]
        pool.wait()

我们定义一个简单的函数来调用一下：

def say(num):
    print(num)

my=MyPool(say,2,[1,2,3,4,5])
my.pool()