`
yy_gy
  • 浏览: 34247 次
  • 性别: Icon_minigender_2
社区版块
存档分类
最新评论

python thread practices

阅读更多
materials:http://www.cnblogs.com/holbrook/archive/2012/02/23/2365420.html

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

1、  函数式:调用thread模块中的start_new_thread()函数来产生新线程。线程的结束可以等待线程自然结束,也可以在线程函数中调用thread.exit()或thread.exit_thread()方法。
import time
import thread

def timer(no,interval):
  cnt=0
 
  while cnt<10:
    print 'thread(%d)'%(cnt)
    time.sleep(interval)
    cnt=cnt+1
 

def test():
  thread.start_new_thread(timer,(1,1))
  thread.start_new_thread(timer,(2,2))

if __name__=='__main__':
  print 'thread starting'
  test()
  time.sleep(20)
  thread.exit_thread()
  print 'exit...'
2、  创建threading.Thread的子类来包装一个线程对象,
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(),检查线程是否在运行中。
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()
"""
"""
问题产生的原因就是没有控制多个线程对同一资源的访问,对数据造成破坏,使得线程运行的结果不可预期。这种现象称为“线程不安全”。
import threading
import time

class MyThread(threading.Thread):
  def run(self):
    for i in range(3):
      time.sleep(1)
      msg='I am '+ self.getName()+'@'+str(i)
      print msg

def test():
  for i in range(5):
    t=MyThread()
    t.start()

if __name__=='__main__':
  test()

上面的例子引出了多线程编程的最常见问题:数据共享。当多个线程都修改某一个共享数据的时候,需要进行同步控制。

线程同步能够保证多个线程安全访问竞争资源,最简单的同步机制是引入互斥锁。互斥锁为资源引入一个状态:锁定/非锁定。某个线程要更改共享数据时,先将其锁定,此时资源的状态为“锁定”,其他线程不能更改;直到该线程释放资源,将资源的状态变成“非锁定”,其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作,从而保证了多线程情况下数据的正确性。其中,锁定方法acquire可以有一个超时时间的可选参数timeout。如果设定了timeout,则在超时后通过返回值可以判断是否得到了锁,从而可以进行一些其他的处理

threading模块中定义了Lock类
import threading
import time

class MyThread(threading.Thread):
  def run(self):
    global num
    time.sleep(1)

    if mutex.acquire():
      num=num+1
      print self.name+' set num to '+str(num)+'\n'
      mutex.release()
num=0
mutex=threading.Lock()

def test():
  for i in range(5):
    t=MyThread()
    t.start()

if __name__=='__main__':
  test()
"""
"""更简单的死锁情况是一个线程“迭代”请求同一个资源,直接就会造成死锁:
import threading
import time

class MyThread(threading.Thread):
    def run(self):
        global num
        time.sleep(1)

        if mutex.acquire(1): 
            num = num+1
            msg = self.name+' set num to '+str(num)
            print msg
            mutex.acquire()
            mutex.release()
            mutex.release()
num = 0
mutex = threading.Lock()
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == '__main__':
    test()
为了支持在同一线程中多次请求同一资源,python提供了“可重入锁”:threading.RLock。RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次require。直到一个线程所有的acquire都被release,其他的线程才能获得资源。上面的例子如果使用RLock代替Lock,则不会发生死锁:
import threading
import time

class MyThread(threading.Thread):
    def run(self):
        global num
        time.sleep(1)

        if mutex.acquire(1): 
            num = num+1
            msg = self.name+' set num to '+str(num)
            print msg
            mutex.acquire()
            mutex.release()
            mutex.release()
num = 0
mutex = threading.RLock()
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == '__main__':
    test()
"""

"""
python多线程编程(5): 条件变量同步

互斥锁是最简单的线程同步机制,Python提供的Condition对象提供了对复杂线程同步问题的支持。Condition被称为条件变量,除了提供与Lock类似的acquire和release方法外,还提供了wait和notify方法。线程首先acquire一个条件变量,然后判断一些条件。如果条件不满足则wait;如果条件满足,进行一些处理改变条件后,通过notify方法通知其他线程,其他处于wait状态的线程接到通知后会重新判断条件。不断的重复这一过程,从而解决复杂的同步问题。

可以认为Condition对象维护了一个锁(Lock/RLock)和一个waiting池。线程通过acquire获得Condition对象,当调用wait方法时,线程会释放Condition内部的锁并进入blocked状态,同时在waiting池中记录这个线程。当调用notify方法时,Condition对象会从waiting池中挑选一个线程,通知其调用acquire方法尝试取到锁。

Condition对象的构造函数可以接受一个Lock/RLock对象作为参数,如果没有指定,则Condition对象会在内部自行创建一个RLock。

除了notify方法外,Condition对象还提供了notifyAll方法,可以通知waiting池中的所有线程尝试acquire内部锁。由于上述机制,处于waiting状态的线程只能通过notify方法唤醒,所以notifyAll的作用在于防止有线程永远处于沉默状态。

演示条件变量同步的经典问题是生产者与消费者问题:假设有一群生产者(Producer)和一群消费者(Consumer)通过一个市场来交互产品。生产者的”策略“是如果市场上剩余的产品少于1000个,那么就生产100个产品放到市场上;而消费者的”策略“是如果市场上剩余产品的数量多余100个,那么就消费3个产品。用Condition解决生产者与消费者问题的代码如下:
import threading
import time

class Producer(threading.Thread):
  def run(self):
    global count
    while True:
      if con.acquire():
        if count>1000:
          con.wait()
        else:
          count=count+100
          print self.name+' produce 100,count='+str(count)

        con.release()
        time.sleep(1)

class Customer(threading.Thread):
  def run(self):
    global count
    while True:
      if con.acquire():
        if count>100:
          count=count-100
          print self.name+ 'consume 100, count='+str(count)
        else:
          con.wait()
        con.release()
        time.sleep(1)

count=500
con=threading.Condition()

def test():
  for i in range(5):
    p=Producer()
    p.start()
    c=Customer()
    c.start()
    print i


if __name__=='__main__':
  test()
python中默认全局变量在函数中可以读,但是不能写但是
对con只读,所以不用global引入"""
分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics