python如何使用多线程_Python中的多线程

使用方法：

thread包：有问题，不好用，python3中改成了_thread

使用方法：_thread.start_new_thead(func_name, tuple)

参数两个，一个是需要运行的函数名，第二是函数的参数作为元祖使用，为空则使用空元祖

注意：如果函数只有一个参数，需要参数后由一个逗号

如_thread.start_new_thread(loop1,("wjw", ))

threading包: python3中常用的包

使用方法：t = threading.Thread(target=xxx, args=(xxx,))

t.start():启动多线程

t.join(): 等待多线程执行完成

守护线程-daemon

- 如果在程序中将子线程设置成守护线程，则子线程会在主线程结束的时候自动退出

使用方法：t.setDaemon(True)或者t.daemon = True

线程常用属性：

- threading.currentThread：返回当前线程变量

- threading.enumerate: 返回一个包含正在运行的线程的list，正在运行的线程指的是线程启动后，结束前

- threading.activeCount: 返回正在运行的线程数量，效果跟len(threading.enumerate)相同

- thr.setName: 给线程设置名字

- thr.getName: 获得线程的名字

importtimeimportthreadingdefloop1():#ctime 得到当前时间

print('Start loop 1 at :', time.ctime())#睡眠多长时间，单位是秒

time.sleep(6)print('End loop 1 at:', time.ctime())defloop2():#ctime 得到当前时间

print('Start loop 2 at :', time.ctime())#睡眠多长时间，单位是秒

time.sleep(1)print('End loop 2 at:', time.ctime())defloop3():#ctime 得到当前时间

print('Start loop 3 at :', time.ctime())#睡眠多长时间，单位是秒

time.sleep(5)print('End loop 3 at:', time.ctime())defmain():print("Starting at:", time.ctime())#生成threading.Thread实例

t1 = threading.Thread(target=loop1, args=( ))#setName是给每一个子线程设置一个名字

t1.setName("THR_1")

t1.start()

t2= threading.Thread(target=loop2, args=( ))

t2.setName("THR_2")

t2.start()

t3= threading.Thread(target=loop3, args=( ))

t3.setName("THR_3")

t3.start()#预期3秒后，thread2已经自动结束，

time.sleep(3)#enumerate 得到正在运行子线程，即子线程1和子线程3

for thr inthreading.enumerate():#getName能够得到线程的名字

print("正在运行的线程名字是： {0}".format(thr.getName()))print("正在运行的子线程数量为： {0}".format(threading.activeCount()))print("All done at:", time.ctime())if __name__ == "__main__":

main()#一定要有while语句

#因为启动多线程后本程序就作为主线程存在

#如果主线程执行完毕，则子线程可能也需要终止

whileTrue:

time.sleep(10)

继承thread的方法：

- 直接继承Thread

- 必须重写run函数，因为当类实例运行的时候就是在运行run函数

- 类实例可以直接运行

importthreadingimporttime#1. 类需要继承自threading.Thread

classMyThread(threading.Thread):def __init__(self, arg):

super(MyThread, self).__init__()

self.arg=arg#2 必须重写run函数，run函数代表的是真正执行的功能

defrun(self):

time.sleep(2)print("The args for this class is {0}".format(self.arg))for i in range(5):

t=MyThread(i)

t.start()

t.join()print("Main thread is done!!!!!!!!")

semaphore：是一个信号量类，每次有线程获得信号量的时候（即acquire()）计数器－1，释放信号量时候(release())计数器＋1，计数器为0的时候其它线程就被阻塞无法获得信号量

importtimeimportthreadingdeffoo():

time.sleep(2) #程序休息2秒

print("ok",time.ctime())for i in range(20):

t1=threading.Thread(target=foo,args=()) #实例化一个线程

t1.start() #启动线程

上述程序会在很短的时间内生成20个线程来打印一句话，如果在主机执行IO密集型任务的时候再执行这种类型的程序时，计算机就有很大可能会宕机，这时候就可以为这段程序添加一个计数器功能，来限制一个时间点内的线程数量，比如设置一个Semaphore(5)，这时每次就只能有5个线程同时运行：

importtimeimportthreading

s1=threading.Semaphore(5) #添加一个计数器

deffoo():

s1.acquire()#计数器获得锁

time.sleep(2) #程序休眠2秒

print("ok",time.ctime())

s1.release()#计数器释放锁

for i in range(20):

t1=threading.Thread(target=foo,args=()) #创建线程

t1.start() #启动线程

threading.Timer：利用多线程在指定时间后调用一个函数

importthreadingimporttimedeffunc():print("I am running.........")

time.sleep(4)print("I am done......")if __name__ == "__main__":

t= threading.Timer(6, func)

t.start()

i=0whileTrue:print("{0}***************".format(i))

time.sleep(3)

i+= 1

输出结果如下：

0***************

1***************I am running.........2***************

3***************I am done......4***************

5***************