理解 python 中多线程

python struggling 863次浏览 0个评论
文章目录

虽然python中由于GIL的机制致使多线程不能利用机器多核的特性,但是多线程对于我们理解并发模型以及底层操作非常有用。

线程的有两种使用方法,一种是在函数使用,一种是放在类中使用

1,在函数中使用多线程

语法如下:

    thread.start_new_thread(function, args[, kwargs] )

参数说明:

    function - 线程函数。

        args - 传递给线程函数的参数,必须是个tuple类型。

        kwargs - 可选参数。

下面是一个例子:

    def run(num):
        print 'hi , i am a thread.', num
    
    def main():
        threads = []
        for i in range(5):
            t = threading.Thread(target=run, args=(i,))
            threads.append(t)
            t.start()
        for t in threads:
            t.join()
    if __name__ == '__main__':
        print 'start -->'
        main()
        print 'go here -->'

运行结果:

    start -->
    hi , i am a thread. 0
    hi , i am a thread. 1
    hi , i am a thread. 2
    hi , i am a thread. 3
    hi , i am a thread. 4
    go here -->

2,在类中多使用线程

下面是在类中使用线程的示例:

    class MyThread(threading.Thread):
        def __init__(self,num):
            self.num = num
            super(MyThread, self).__init__()
        def run(self):
            print 'i am a thread,',self.num
            time.sleep(1)
    
    def main():
        threads = []
        for i in range(5):
            t = MyThread(i)
            threads.append(t)
            t.start()
        for t in threads:
            t.join()
    
    if __name__ == '__main__':
        print 'start -->'
        main()
        print 'go here -->
  • run(),需要重写,编写代码实现所需要的功能。
  • getName(),获得线程对象名称
  • setName(),设置线程对象名称
  • start(),启动线程
  • join([timeout]),等待另一线程结束后再运行。
  • setDaemon(bool),设置子线程是否随主线程一起结束,必须在start() 之前调用,默认为False
  • isDaemon(),判断线程是否随主线程一起结束。
  • isAlive(),检查线程是否在运行中。

join方法的作用是阻塞主进程(无法执行join以后的语句),主线程等待这个线程结束后,才可以执行下一条指令。多线程多join的情况下,依次执行各线程的join方法,前头一个结束了才能执行后面一个。无参数,则等待到该线程结束,才开始执行下一个线程的join。设置参数后,则等待该线程这么长时间就不管它了(而该线程并没有结束)。不管的意思就是可以执行后面的主进程了。

3,线程同步与互斥锁

线程之所以比进程轻量,其中一个原因就是他们共享内存。也就是各个线程可以平等的访问内存的数据,如果在短时间“同时并行”读取修改内存的数据,很可能造成数据不同步。例如下面的例子:

    var = 0
    class IncreThread(Thread):
        def run(self):
            global var
            print 'before,var is ',var
            var += 1
            print 'after,var is ',var
    
    def use_incre_thread():
        threads = []
        for i in range(50):
            t = IncreThread()
            threads.append(t)
            t.start()
        for t in threads:
            t.join()
        print 'After 10 times,var is ',var
    
    if __name__ == '__main__':
        use_incre_thread()

有一个全局变量var,五十个线程,每个线程对var变量进行加 1 运算,但是当你多运行几次后,发现并不是每次的运行结果都是 50,为什么呢?

var是 10 的时候,线程t1读取了var,这个时刻cpu将控制权给了另一个线程t2t2线程读到的var也是 10,t1t2都把var加到 11,当时我们期望的是t1 t2两个线程使var + 2 变成 12。在这里就有了资源竞争,相同的情况也可能发生在其它的线程间,所以出现了最后的结果小于 50 的情况。

为了避免线程不同步造成数据不同步,可以对资源进行加锁。也就是访问资源的线程需要获得锁,才能访问。threading 模块提供了一个 Lock 功能,修改代码如下:

    var = 0
    lock = Lock()  #创建锁
    class IncreThread(Thread):
        def run(self):
            global var
            lock.acquire()  #获取锁
            print 'before,var is ',var
            var += 1
            print 'after,var is ',var
            lock.release()  #释放锁
    
    def use_incre_thread():
        threads = []
        for i in range(50):
            t = IncreThread()
            threads.append(t)
            t.start()
        for t in threads:
            t.join()
        print 'After 10 times,var is ',var
    
    if __name__ == '__main__':
        use_incre_thread()

虽然线程可以共享内存,但是一个线程不能影响其他线程内的变量(非全局变量)。

4,死锁

在线程间共享多个资源的时候,如果两个线程分别占有一部分资源并且同时等待对方的资源,就会造成死锁。尽管死锁很少发生,但一旦发生就会造成应用的停止响应。下面是一个死锁的例子:

    mutex_a = Lock()
    mutex_b = Lock()
    
    class MyThread(Thread):
        def task_b(self):
            if mutex_a.acquire():
                print 'thread get a mutex_a',self.name
                time.sleep(1)
                if mutex_b.acquire():
                    print 'get a mutex_b',self.name
                    mutex_b.release()
                mutex_a.release()
                
        def task_a(self):
            if mutex_b.acquire():
                print 'thread get a mutex_b',self.name
                time.sleep(1)
                if mutex_a.acquire():
                    print 'get a mutex_a',self.name
                    mutex_a.release()
                mutex_b.release()
                
        def run(self):
            self.task_a()
            self.task_b()
    
    if __name__ == '__main__':
        threads = [MyThread() for i in range(2)]
        print threads
        for t in threads:
            t.start()

线程需要执行两个任务,两个任务都需要获取锁,当两个任务得到锁后,就需要等另外锁释放。

5,可重入锁

为了支持在同一线程中多次请求同一资源,python 提供了可重入锁(RLock)。RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次require。直到一个线程所有的acquire都被release,其他的线程才能获得资源。

    mutex = threading.RLock()
    class MyThread(threading.Thread):
        def run(self):
            if mutex.acquire(1):
                print 'threading gte mutex:',self.name
                time.sleep(1)
                mutex.acquire()
                mutex.release()
                mutex.release()
    
    def main():
        print 'start main threading:'
        threads = [MyThread() for i in range(2)]
        for t in threads:
            t.start()
        for t in threads:
            t.join()
        print 'end main threading.'
    
    if __name__ == '__main__':        
        main()

6,后台线程

使用多线程默认情况下,当主线程退出之后,即使子线程没有 join,子线程也依然会继续执行。如果希望主线程退出后,其子线程也退出而不再执行,则需要设置子线程为后台线程。python提供了setDaemon方法,将子线程与主线程进行绑定,当主线程退出时子线程的生命也随之结束。

    class MyThread(threading.Thread):
        def run(self):
            wait_time = random.randrange(1, 10)
            print 'thread %s will wait %s s' %(self.name, wait_time)
            time.sleep(wait_time)
            time.sleep(30)
            print 'thread %s finished.' % self.name
    
    
    def main():
        print 'start thread:'
        for i in range(3):
            t = MyThread()
            t.setDaemon(1)
            t.start()
        print 'end thread.'
    
    if __name__ == '__main__':
        main()

运行结果:

    start thread:
    thread Thread-1 will wait 9 s
    thread Thread-2 will wait 1 s
     thread Thread-3 will wait 7 s
    end thread.

本来子线程需要等待几秒才能结束,但是主线程提前结束了,所以子线程也随主线程结束了。


DevOps-田飞雨 》》转载请注明源地址
喜欢 (6)or分享 (0)
发表我的评论
取消评论
*

表情 贴图 加粗 链接 删除线 居中 斜体 签到

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址