python 继承式多线程

Thread是线程类，有两种使用方法，直接传入要运行的方法或从Thread继承并覆盖run()：

 

Thread继承

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

import threading import time   class MyThread(threading.Thread):     def __init__(self,n):         super(MyThread,self).__init__()         self.n = n       def run(self):         print("runnint task",self.n)   t1 = MyThread("t1") t2 = MyThread("t2")   t1.start() #runnint task t1 t2.start() #runnint task t2

 以上是通过类的方式创建线程。

关于Thread类

构造方法： 
Thread(group=None, target=None, name=None, args=(), kwargs={}) 

　　group: 线程组，目前还没有实现，库引用中提示必须是None； 
　　target: 要执行的方法； 
　　name: 线程名； 
　　args/kwargs: 要传入方法的参数。

实例方法： 
　　isAlive(): 返回线程是否在运行。正在运行指启动后、终止前。 
　　get/setName(name): 获取/设置线程名。 

　　start():  线程准备就绪，等待CPU调度
　　is/setDaemon(bool): 获取/设置是后台线程（默认前台线程（False））。（在start之前设置）

　　　　如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，主线程和后台线程均停止
       　　如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
　　start(): 启动线程。 
　　join([timeout]): 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout（可选参数）。

直接运行

 

 

将要执行的方法作为参数传给Thread的构造方法

1 2 3 4 5 6 7 8 9 10 11 12 13

import threading import time def run(n):     print("task ",n)     time.sleep(2)     print('task done',n)   start_time = time.time() for i in range(5):     t = threading.Thread(target=run,args=("t-%s" %i,))     t.start() print('cost:',time.time() - start_time )

 1 task  t-0
 2 task  t-1
 3 task  t-2
 4 task  t-3
 5 task  t-4
 6 cost: 0.0 #打印时间 停留2秒 继续执行
 7 task done t-1
 8 task done t-0
 9 task done t-3
10 task done t-2
11 task done t-4

 

一个程序至少有一个主线程。当一个线程启动一个子线程之后，那么相互是独立的、并行的。

主线程启动一个子线程之后并没有等待这个子线程执行完毕就往下走。

所以程序会一直执行到打印时间，也是程序结束。这个run（）函数是子线程在执行，主线程执行完以后相当于创建完最后一个子线程，那么这个子线程继续执行run（）,所以会等待2秒。在这之后又继续执行print('task done',n)。因为每个线程都是独立并行执行的。这个2秒是每个线程都要等待的。然后又执行print('task done',n)。

 以上只是测试了一个线程创建花费了多少时间。

怎么测试这些线程创建总共花费了多少时间？

默认情况下主线程执行并不会等待子线程，并且执行完毕了以后就退出了。

那么可以设置主线程等待子线程的执行结果，就可以计算创建子线程总共花费的时间。

join

join（）等待子线程执行结果。程序默认是有一个join 因为要等待所有线程执行完毕以后才退出。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

import threading import time   class MyThread(threading.Thread):     def __init__(self,n):         super(MyThread,self).__init__()         self.n = n       def run(self):         print("runnint task",self.n)         time.sleep(2)   t1 = MyThread("t1") t2 = MyThread("t2")   t1.start() t1.join() #等待t1执行结果(等待2s) t2.start()

 加了join之后程序等待了2s之后在执行t2，t2有等待了2s之后程序结束。

相当于把并行的程序改成了串行。

先创建线程在等待。其实和没等待是一样的。因为这个程序还是在并行执行，等待t1的过程就是在等待所有线程的过程。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

import threading import time   class MyThread(threading.Thread):     def __init__(self,n):         super(MyThread,self).__init__()         self.n = n       def run(self):         print("runnint task",self.n)         time.sleep(2)   t1 = MyThread("t1") t2 = MyThread("t2")   t2.start() t1.start() t1.join() #等待t1执行结果(等待2s) print('main thread...')

 主要原因是因为每个线程的等待时间是一样的，所以看不出来，如果每个线程的创建时间不一样就可以看出效果。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

import threading import time   class MyThread(threading.Thread):     def __init__(self,n,sleep_time):         super(MyThread,self).__init__()         self.n = n         self.sleep_time = sleep_time     def run(self):         print("runnint task",self.n)         time.sleep(self.sleep_time)   t1 = MyThread("t1",2) t2 = MyThread("t2",4)     t1.start() t2.start() t1.join() #等待t1执行结果(等待2s) print('main thread...') #等待t2执行结果(等待2s)

 因为是一起创建的线程，所以等待的时间是一起计算的。要计算t2的创建时间也要等待t2结束，主程序才能结束。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

import threading import time   class MyThread(threading.Thread):     def __init__(self,n,sleep_time):         super(MyThread,self).__init__()         self.n = n         self.sleep_time = sleep_time     def run(self):         print("runnint task",self.n)         time.sleep(self.sleep_time)   t1 = MyThread("t1",2) t2 = MyThread("t2",4)     t1.start() t2.start() t1.join() #等待t1执行结果(等待2s) t2.join() #等待t2执行结果(等待2s) print('main thread...')

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

import threading import time def run(n):     print("task ",n)     time.sleep(2)     print('task done',n)   start_time = time.time() t_objs = []  #定义一个列表存放实例 for i in range(5):     t = threading.Thread(target=run,args=("t-%s" %i,))     t.start()     t_objs.append(t) #为了不阻塞后面的线程的启动，不在这里join 先放到一个列表里     for t in t_objs:   #循环每个实例     t.join()        print('cost:',time.time() - start_time )

 运行结果

1 2 3 4 5 6 7 8 9 10 11

task  t-0 task  t-1 task  t-2 task  t-3 task  t-4 task done t-0 task done t-4 task done t-3 task done t-2 task done t-1 cost: 2.004605770111084