Python 多线程

基本概念：

线程指的是：进程中的每个子任务，不能同时存在、

进程：独立的所有的子任务的集合

线程和进程：目的都是想同时完成任务

进程的特点：独立（CPU使用独立，内存独立）、启动进程开销大（速率低） 进程之间很难共享数据，和数据通信

Python3 线程中常用的两个模块为：

1. _thread
2. threading(一般使用这个)

Python中使用线程有两种方式：函数或者用类来包装线程对象。

     函数式：调用 _thread 模块中的start_new_thread()函数来产生新线程。

[html]  view plain  copy

 print ?

1. _thread.start_new_thread ( function, args[, kwargs] )  

具体小例子：

[html]  view plain  copy

 print ?

1. import threading  
2. import time  
3. def test():  
4.     for i in range(11):  
5.         print(i)  
6.         time.sleep(1)  
7. print('-----main------')  
8. threading._start_new_thread(test,())  
9. for i in range(50,39,-1):  
10.     print(i)  
11.     time.sleep(1)  
12. input()  

第二种是线程类方法

[html]  view plain  copy

 print ?

1. import threading  
2. import time  
3. class Mythread(threading.Thread):  
4.     def __init__(self,name = None):  
5.         threading.Thread.__init__(self)  
6.         self.name = name  
7.         print('mythreading......')  
8.     def run(self):  
9.         for i in range(11):  
10.             print("%s \t %d"%(self.name,i))  
11.             time.sleep(1)  
12.     def start(self):  
13.         print("旭辉，站着吃不着鸡")  
14.         super().start()  
15. t = Mythread("ewew")  
16. t2 = Mythread("sdfd")  
17. t.start()  
18. t2.start()  
19. for i in range (50,39,-1):  
20.     print(i)  
21.     time.sleep(1)  

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

• run(): 表示线程活动的方法。
• start():调用start()方法，启动线程

• join([time]): 如线程一正在运行， 线程二突然穿插进来，接下来运行的应是线程二！等线程2运行结束，再是1
• isAlive(): 返回线程是否活动的
• getName(): 返回线程名
• setName(): 设置线程名

接下来谈一谈线程锁的实例：

       可以通过直接从 threading.Thread 继承创建一个新的子类，并实例化后调用 start() 方法，启动新线程，即它调用了线程的 run() 方法：

[html]  view plain  copy

 print ?

1. import threading  
2. import time  
3. class Mythread(threading.Thread):           #线程一    写一个类继承threading.Thread  
4.     def run(self):  
5.         for i in range(11):  
6.             if i == 3:  
7.                  cond.acquire()         #当运行到3的时候，将线程1锁住  
8.                  cond.wait()  
9.                  cond.release()  
10.             print(i)  
11.             time.sleep(1)  
12. t = Mythread()  
13. t.start()  
14.   
15.   
16. lock = threading.Lock()             #写一个锁的方法Lock()  
17. cond = threading.Condition(lock=lock)  
18. class Mythread2(threading.Thread):  
19.     def run(self):  
20.         for i in range(50,39,-1):  
21.             print(i)  
22.             time.sleep(1)  
23.         cond.acquire()  
24.         cond.notify()             #线程二和线程一，共用一个锁，当线程二运行结束，用notify()唤醒线程一，并解锁继续运行  
25.         cond.release()  
26.   
27. t1 = Mythread2()  
28. t1.start()  

 线程从创建、运行到结束总是处于下面五个状态之一：新建状态  、就绪状态  、运行状态  、阻塞状态 及死亡状态。

a ) 新建状态(New)： 
        当用new操作符创建一个线程时， 例如new Thread(r)，此时线程处于新建状态， 程序还没有开始运行线程中的代码

b)就绪状态(Runnable)

        一个新创建的线程，自己不会自动开始运行。要执行线程的话，必须去调用start()方法。当线程对象调用start()方法时，就意味着启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。

如果是多线程的话，处于就绪状态的线程，不一定马上去运行run()方法，它还必须要跟其他的线程竞争CPU，只有在获得CPU时间后，才可以运行线程。因为在单CPU的计算机系统中，多个线程是不可能一起运行的，在某一个时间点，只会有一个线程是正在运行。这个时候处于就绪状态的就不一定是一个，也有可能是好几个

c)运行状态(Running) :      一个线程，它在获得CPU时间后，才进入运行状态，真正开始执行run()方法

d)阻塞状态(Blocked):        线程运行过程中，会因为各种原因，进入到阻塞状态:

        1。线程通过调用sleep方法进入睡眠状态；
        2。线程想要得到一个锁，而这个锁正被其他线程占着，用不了；
        3。线程在等待某个触发条件；
        ......    
        说白了，阻塞状态说的就是： 正在运行的线程还没有运行结束，只是暂时的让出CPU，这个时候其他处于就绪状态的线程，就获得了CPU的时间，进入运行状态。

 e)死亡状态(Dead) :    两个原因会导致线程死亡

           (1) run方法正常退出而自然死亡，
           (2) 一个未捕获的异常,终止了run方法,而使线程死亡。
        为了确定线程在当前是否存活着（一个是被阻塞了，二个是正常在运行着），就要用到isAlive方法。  如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态，且不是可运行的， 或者线程死亡了，则返回false。