CWYAlpha

Just another WordPress.com site

Thought this was cool: python多线程

leave a comment »


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

#encoding:utf8

import threading
import time

class timer(threading.Thread):
    def __init__(self,num,interval):
        threading.Thread.__init__(self)
        #设置产生线程的个数
        self.thread_num = num
        #产生线程的相隔时间
        self.interval = interval
        self.thread_stop = False

    def run(self):
        while not self.thread_stop:
            print Thread Object(%d),Time:%s\n%(self.thread_num,time.ctime())
            time.sleep(self.interval)

    def stop(self):
        self.thread_stop = True

def test():
    thread1 = timer(1,1)
    thread2 = timer(2,2)
    thread1.start()
    thread2.start()
    time.sleep(10)
    thread1.stop()
    thread2.stop()
    return

if __name__ == __main__:
    test()
    

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(),检查线程是否在运行中。

    此外threading模块本身也提供了很多方法和其他的类,可以帮助我们更好的使用和管理线程。可以参看http://www.python.org/doc/2.5.2/lib/module-threading.html
2.简单的同步

#encoding:utf8

import threading

mylock = threading.RLock()
num 
= 0

class myThread(threading.Thread):
    
def __init__(self,name):
        threading.Thread.
__init__(self)
        self.t_name 
= name

    def run(self):
        
global num
        
while True:
            mylock.acquire()
            
print \nThread(%s) locked,Number:%d%(self.t_name,num)
            
if num >= 4:
                mylock.release()
                
print \nThread(%s) released,Number:%d%(self.t_name,num)
                
break
            num 
+= 1
            
print \nThread(%s) released,Number:%d%(self.t_name,num)
            mylock.release()

def test():
    thread1 
= myThread(A)
    thread2 
= myThread(B)
    thread1.start()
    thread2.start()

if __name__ == __main__:
    test()

   Pythonthreading module是在建立在thread module基础之上的一个module,在threading module中,暴露了许多thread module中的属性。在thread module中,python提供了用户级的线程同步工具“Lock”对象。而在threading module中,python又提供了Lock对象的变种: RLock对象。RLock对象内部维护着一个Lock对象,它是一种可重入的对象。对于Lock对象而言,如果一个线程连续两次进行acquire操作,那么由于第一次acquire之后没有release,第二次acquire将挂起线程。这会导致Lock对象永远不会release,使得线程死锁。RLock对象允许一个线程多次对其进行acquire操作,因为在其内部通过一个counter变量维护着线程acquire的次数。而且每一次的acquire操作必须有一个release操作与之对应,在所有的release操作完成之后,别的线程才能申请该RLock对象。修改共享数据的代码成为“临界区”。必须将所有“临界区”都封闭在同一个锁对象的acquirerelease之间。

SunRise_at 2013-01-04 14:25 发表评论

from C++博客_Kevin Lynx: http://www.cppblog.com/sunrise/archive/2013/01/04/196939.html

Written by cwyalpha

一月 16, 2013 在 11:38 上午

发表在 Uncategorized

发表评论

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / 更改 )

Twitter picture

You are commenting using your Twitter account. Log Out / 更改 )

Facebook photo

You are commenting using your Facebook account. Log Out / 更改 )

Google+ photo

You are commenting using your Google+ account. Log Out / 更改 )

Connecting to %s

%d 博主赞过: