为了账号安全,请及时绑定邮箱和手机立即绑定

Python多线程解析

2018.06.17 12:51 569浏览

概述

记得前些日子伞哥发过一个微博调侃过Python由于GIL锁的存在,所以现在死活想把自己和机器学习扯上关系。确实,由于这个全局解释锁的存在,任何时刻只有一个核在执行Python代码,这样就导致不能充分利用多核处理器的特性。但是,我们的程序也不总是在计算的,程序有IO密集型和CPU计算密集型。如果我们的程序需要等待用户输入,等待文件读写以及网络收发数据,那计算机就会把这些等待操作放到后台去处理,把CPU留出来用于计算。所以,虽然CPU密集型的程序用Python多线程确实无法提高效率,但是如果是IO密集型的程序,是可以使用多线程提高效率的。

接下来,让我们通过例子一步一步了解多线程:

利用threading模块使用多线程

Python标准库自带了两个多线程模块,分别是threadingthread,其中,thread是低级模块,threading是对thread的封装,一般,我们直接使用threading即可。下面来看一个简单的多线程例子:

import threadingdef say_hello():
    print("Hello world!")def main():
    for i in range(10):
        thread = threading.Thread(target=say_hello)
        thread.start()

main()

在这个例子中,我们首先定义了要多线程执行的函数say_hello,然后我们在主函数里创建了10个线程,target取值是say_hi,告诉线程要执行的函数,然后我们调用start()方法吩咐线程去执行这些线程。
这个程序最终会输出5个Hello world!,与["Hello world!" for i in range(10)]效果一致,那么为什么还要使用多线程呢,我们通过下面这个例子理解下多线程的意义:

import threadingimport timedef say_hello():
    time.sleep(1)
    print("Hello world!")def main():
    for i in range(10):
        thread = threading.Thread(target=say_hello)
        thread.start()

main()

在这个例子里,我们加了time.sleep(1)来模拟等待事件。现在如果用普通的循环来迭代,代码执行完需要至少5秒,而多线程运行只需要1秒多,减少了程序整体运行的时间。

给线程传参和线程常用方法

在上面的代码中,我们并没有给say_hello传参数,在多线程里传参很简单,只需要这样做就好了:

import threadingdef say_hello(count, name):
    print("Hello world!", name)
    count -= 1def main():
    name_list = ['Bob', 'Jack', 'Jone', 'Mike', 'David']    for i in range(5):
        thread = threading.Thread(target=say_hello, args=(10, name_list[i]))
        thread.start()

main()

threading.Thread类中,常用的方法有:

  • isAlive: 检查线程是否在运行中

  • getName: 获取线程名称

  • setName: 设置线程名称

  • join:阻塞线程调用,直到线程中止

  • setDaemon:设置线程为守护线程

  • isDaemon: 判断线程是否是守护线程

通过继承创建线程

除了直接实例化threading.Thread对象,我们还可以通过继承threading.Thread来编写多线程的类。然后把多线程调用的函数携程一个run方法。方法如下:

import threadingclass MyThread(threading.Thread):
      def __init__(self, count, name):          super(MyThread, self).__init__()          self.count = count          self.name = name     
      def run(self):          while self.count > 10:
                print("hello", self.name) 
                self.count -= 1

线程与互斥锁

多个线程之间 内存是共享的,所以线程比进程轻量。多个线程是可以同时访问内存中的数据的,如果多个线程同时修改一个对象,那这份数据可能会被破坏,Python的threading类中提供了Lock方法,它会返回一个锁对象,一般通过lock.acquire()来获取锁,通过lock.release()来释放锁,对于那种只允许一个线程操作 的数据,一般把对其的操作放在lock.acquire()lock.release()中间。
无论在什么情况下,我们都要保证代码要释放锁,所以其他语言中一般把加锁和释放锁放在try/finally语句中。在Python中,其实我们可以用上下文管理器来简化代码,关于上下文管理器的介绍可以参考我前面的文章:上下文管理器,这里我们可以这样使用锁:

with lock:    #lock processing

下面来看一个使用互斥锁的例子,在这个例子中,我们使用了全局变量,然后创建10个线程,每个线程做同样的事情,由于num是全局变量,而且每个线程都需要使用这个变量,因此存在着数据争用的问题,所以,我们就需要使用互斥锁保护这个全局变量:所有修改这个变量的线程在修改前都需要加锁,在increment函数中,我们通过with语句进行加锁。如下所示:

import threading

lock = threading.Lock()
num = 0def increment(count):
    global num    while count > 0:        with lock:
            num += 1
        count -= 1def main():
    threads = []    for i in range(10):
        thread = threading.Thread(target=increment,args=(100,))
        thread.start()
        threads.append(thread)    for thread in threads:
        thread.join()

    print("except value is 1000, real value is{}".format(num))
    
main()

有兴趣的读者可以试试把锁去掉是什么结果,实际上,我们永远得不到正确的结果。

对于这段代码,我们可以这样理解:

    threads = []    for i in range(10):
        thread = thread.Threading(target=increment, args=(100,))
        thread.start()
        threads.append(thread) 
    for thread in threads:
        thread.join()

第一个for循环,意思是吩咐十个线程去做target里面的事,执行完第一个for循环后就吩咐完了,但仅仅是只是吩咐完了,target里面的任务没有执行完,因为不知道是否执行完,所以还需要创建一个列表把他们都保存起来。对于第二个for循环,如果在第一个循环里 他们的target已经执行完了,那后面直接就join,不用等待,遇到有的线程没有执行完的,join 就阻塞调用,直到这些线程执行完。

线程安全队列queue

队列是线程间最常用的交换数据的形式,queue模块实现了线程安全的队列,有三种类型的队列:

  • queue Queue:FIFO(先进先出) 的队列。最常用的队列!

  • queue LifoQueue: LIFO(后进先出)的队列,最后加入队列的元素最先取出

  • queue PriorityQueue: 优先级队列,队列中的元素根据优先级排序。

下面是Queue类常用的方法:

  • empty: 判断队列是否为空

  • full: 判断队列是否已满

  • put: 向队列中添加元素

  • get: 从队列中取出元素

  • put_nowait: 非阻塞 向队列中添加元素

  • get_nowait: 非阻塞 从队列中取出元素

  • join:阻塞等待,直到所有任务完成

来看一个官方给的多线程模型:

def worker():
    while True:
    item = q.get()
    do_work()
    q.task_done()

q = Queue()for i in range(thread_number):
    t = Thread(target=worker)
    t.daemon = True
    t.start()for item in source():
    q.put(item)  

q.join()

之后会有一个线程池的例子运用Queue队列。写完后放链接!待续!



作者:一根薯条
链接:https://www.jianshu.com/p/3b164cef76b8


点击查看更多内容
2人点赞

若觉得本文不错,就分享一下吧!

评论

相关文章推荐

正在加载中
意见反馈 邀请有奖 帮助中心 APP下载
官方微信

举报

0/150
提交
取消