python 多线程

在谈多线程之前我们先谈谈，进程和线程的关系。


一个简单的hello world程序，其实就是一个进程在运行。


那么这个进程有多少线程组成呢，答案是一。


程序的执行是顺序的，只有等到上一条语句执行完毕才到下一条执行语句。那么如果我需要程序在不断打印hello world的同时又在不断地打印good bye world呢？在没学多线程之前我们会觉得很麻烦，但是当你学了多线程时候你就发现其实很简单的一个操作。开一个线程打印hello world 一个线程打印good bye world 就可以。


接下来看看 ，怎么去实现多线程。


python 实现多线程，一般来说有两种方式：


1. 函数式：调用thread模块中的start_new_thread()函数来产生新线程

eg:

import time
import thread


def timer(id, interval):

cnt = 0

while cnt<10:

print 'Thread:(%d) cnt: (%d) Time:%s\n'%(id,cnt,time.ctime())

time.sleep(interval)

cnt += 1

thread.exit_thread()

def main():

thread.start_new_thread(timer,(1,1))

thread.start_new_thread(timer,(2,2))

if __name__ == '__main__':

main()


接下来还等什么。。。赶紧跑起。。。。可是我们会发现。。。运行时候报错。。。。
错误信息为：
Unhandled exception in thread started by


Error in sys.excepthook:


Original exception was:


这什么意思啊，我们的程序都是照着书本敲的，为什么会报该类错误？


其实很简单，我们启动程序时候是有一个主进程在运行的，新起一个子线程执行别的任务，但是当主线程已经执行完毕，子线程还没有执行完毕呢？这时候就会抛出中断异常。（这也与子线程是否是后台进程无关）


知道原因，自然就有解决办法，我们可以延长主线程存活的时间，主线程没事干怎么办？。。。等待是一个好办法。。。


解决：

def main():

thread.start_new_thread(timer,(1,1))


thread.start_new_thread(timer,(2,2))

time.sleep(20) #注意，主线程存活时间一定大于其子线程存活时间，sleep时间具体是多少，可以估量


接下来，程序跑起。。。。。没问题。。。。。。


---------------------------------------------------------------------------------------------------


2. 创建threading.Thread的子类来包装一个线程对象

import time
import threading


class Timer(threading.Thread):


def __init__(self, id, interval):

threading.Thread.__init__(self)

self.id = id

self.interval = interval

self.thread_stop = False


def run(self):

cnt = 0

while not self.thread_stop:

print 'Thread:(%d) cnt:(%d) Time:(%s)\n'%(self.id, cnt, time.ctime())

time.sleep(self.interval)

cnt += 1

def stop(self):

self.thread_stop = True

def main():


timer1 = Timer(1,1)

timer2 = Timer(2,2)

timer1.start()

timer2.start()

time.sleep(20)

timer1.stop()

timer2.stop()

if __name__ == '__main__':

main()


run方法是必须要实现的一个方法。。。。stop方法是为了控制子进程结束进程而添加的。。。


废话少说。。。程序跑起。。。。。。。。
-----------------------------------------------------------------------------------------------


就个人来说，我比较喜欢，第二种方法，自己定制线程类，还可以控制子线程的存活时间


threading.Thread 主要方法有：
1，在自己的线程类的__init__里调用threading.Thread.__init__(self, name = threadname)

Threadname为线程的名字

2， run()，通常需要重写，编写代码实现做需要的功能。

3，getName()，获得线程对象名称

4，setName()，设置线程对象名称

5，start()，启动线程

6，jion([timeout])，等待另一线程结束后再运行。

7，setDaemon(bool)，设置子线程是否随主线程一起结束，必须在start()之前调用。默认为False。

8，isDaemon()，判断线程是否随主线程一起结束。

9，isAlive()，检查线程是否在运行中。

------------------------------------------------------------------------------------------------

3. 进程加锁机制：

大家都听过生产者和消费者问题吧，没听过的自己百度去，我在这里就不赘述，直入正题吧。


import threading

import random

class Consumer(threading.Thread): #消费者

def __init__(self):

threading.Thread.__init__(self)

def run(self):

global container

con.acquire()

if len(container) <= 1:

con.wait()

con.notify()

else:

while len(container)> 1:

bread = container.pop()

print 'eat a bread %d'%(bread.getId())

con.release()

def __del__(self):

print 'consumer distructor'

class Master(threading.Thread): #生产者

def __init__(self):

threading.Thread.__init__(self)

def run(self):

global container

con.acquire()

if len(container) >= 20:

con.wait()

con.notify()

else:

while len(container) < 20:

bread = Bread(random.randint(10, 100))

print 'produce a bread %d'%(bread.getId())

container.append(bread)

con.release()

def __del__(self):

print 'Master Constructor'

class Bread(): #产品

def __init__(self,id):

self.id = id

def getId(self):

return self.id

def __del__(self):

print 'Bread constructor'


container = []

con = threading.Condition()

mas = Master()

cons = Consumer()

mas.start()

cons.start()