【Python】多线程 & 多进程（1）_python 多线程哪个快用哪个-CSDN博客

本文链接：https://blog.csdn.net/zizi7/article/details/79074571

由于GIL（全局解释器锁）的机制，Python同一时刻只有一个线程在跑。
因此 Python 的多线程实际仍然是串行执行，只对IO密集型程序有意义，对于CPU密集型程序，建议多进程

如果不确定多线程还是多进程，可以用 multiprocessing 的 dummy，他以多进程的API实现了多线程的机制

#多进程
from multiprocessing import Pool
#多线程
from multiprocessing.dummy import Pool
#看哪个快用哪个

多线程

Python提供两个模块实现多线程：thread 和 threading，后者是对前者的封装，不推荐用前者

基本用法

1）直接调用函数

import threading

def thread_func(num):
    print 'current thread: threading.currentThread().getName()'
    print '%d'%(num**2)

if __name__ == '__main__':
    thre = threading.Thread(target=thread_func, args=(2,))
    thre.start()
    thre.join()

2）封装成类
直接从 threading.Thread 继承

import threading

class myThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        # 其他需要用到的参数
        self.param1 = ...

    def run(self):
        thread_func(self.param1, ...)

def thread_func(param1,...):
   ...

# 创建新线程
thread = myThread(param1, ...)
# 开启线程
thread.start()

thread.join()

线程同步

1）互斥锁 Lock RLock

threading 提供了两种锁：Lock 和 RLock
两种锁都实现了 acquire() 和 release() 方法
如果一个锁的状态是 unlocked，调用 acquire() 会将其改变为 locked，调用 release() 会抛出异常
如果一个锁的状态是 locked，调用 acquire() 会阻塞，知道其他线程调用 release() 释放锁

import threading

# 全局数据
count = 0
# 互斥锁
mutex = threading.Lock()

class MyThread(threading.Thread):
    def run(self):
        global count
        time.sleep(1)
        # 获取锁，修改资源
        if mutex.acquire():
            for i in range(100):
                count += 1
            print 'thread {} add 1, count is {}'.format(self.name, count)
            # 释放锁
            mutex.release()

        # 也可以用 with 自动实现 acquire 和 release
        with mutex:
            for i in range(100):
                count += 1
                print 'thread {} add 1, count is {}'.format(self.name, count)

RLock 的意义：

考虑这样一种情况：一个函数内使用 Lock 保护了另一个子函数，但子函数内也用到这个 Lock来保护其他数据。这样就造成了死锁，因为子函数内的 Lock 需要等主函数的 Lock release 才能解除阻塞
解决办法上就是，使用 RLock（递归锁）。它允许多次 acquire（release需要与之成对出现）
因此保险起见，优先使用 RLock（mutex = threading.RLock()）

2）条件变量 Condition

Condition 除了 acquire 和 release ，还提供了 wait 和 notify 方法对复杂线程同步问题做支持
线程首先 acquire 一个条件变量，然后判断一些条件。如果条件不满足则 wait，并释放内部的锁；如果条件满足，进行一些处理改变条件后，通过 notify 通知其他线程，其他处于 wait 的线程接到通知后会重新判断条件
wait 要通过 notify 来解除阻塞，但 notify 并不会释放锁，还是需要显式 release 来释放
与 Lock 和 RLock 一样，Condition 也支持上下文管理 with
条件变量的一个典型应用是“生产消费者模型”

# 摘自：http://www.cnblogs.com/holbrook/archive/2012/03/13/2394811.html

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
                    msg = self.name+' produce 100, count=' + str(count)
                    print msg
                    con.notify()
                con.release()
                time.sleep(1)

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

3）信号量 Semaphore

互斥锁确保每次只有一个线程访问保护内容，信号量可以指定线程数目，每次允许该数目的线程同时访问
每调用一次 acquire ，计数器减1；每调用一次 release，计数器加1；当计数器为0时，acquire被阻塞

import time
import threading
# 最多允许 3 个线程同时访问
semaphore = threading.Semaphore(3)

def func():
    if semaphore.acquire():
        for i in range(3):
            time.sleep(1)
            print (threading.currentThread().getName() + '获取锁')
        semaphore.release()
        print (threading.currentThread().getName() + ' 释放锁')

4）事件 Event

一个线程通过 set 发送事件，另外的线程通过 wait 等待事件被触发

# 摘自：http://www.cnblogs.com/aguncn/p/6092611.html

event = threading.Event()
class Consumer(Thread):
    def __init__(self, items, event):
        Thread.__init__(self)
        self.items = items
        self.event = event

    def run(self):
        while True:
            time.sleep(2)
            #消费者等待事件被触发
            self.event.wait()
            item = self.items.pop()
            print("Consumer notify: %d poped from list by %s"
                  %(item, self.name))

class Producer(Thread):
    def __init__(self, items, event):
        Thread.__init__(self)
        self.items = items
        self.event = event

    def run(self):
        global item
        for i in range(10):
            time.sleep(2)
            item = random.randint(0, 256)
            self.items.append(item)
            print ("Producer nofity: item N %d appended to list by %s"
                   % (item, self.name))
            print ("Producer notify: event set by %s "
                   % self.name)
            # 生产者触发事件
            self.event.set()
            print("Produce notify: event clear by %s\n"
                  % self.name)
            self.event.clear()

5）队列 Queue

Queue并不是 threading 里的子模块，但其内部实现了锁的处理，自动实现线程同步
提供了 3 种队列：
Queue.Queue(maxsize) - 先进先出
Queue.LifoQueue(maxsize) - 先进后出
Queue.PriorityQueue(maxsize) - 优先级越低越先出来

如果 maxsize < 1 表示队列无限长
- 主要用到以下4个方法：

Queue.Queue.get([block [, timeout]]) - 删除并返回一个 item，block 默认为 True，表示当队列为空时阻塞线程，timeout 表示阻塞超时
Queue.Queue.put([block [, timeout]]) - 插入一个 item
Queue.Queue.task_done() - get 并处理完一个数据后调用 task_done 表示本任务完成
Queue.Queue.join() - 直到所有 item 都调用了 task_done 后主线程才继续执行

# 摘自： https://www.jianshu.com/p/0e4ff7c856d3

import Queue

queue = Queue.Queue(10)

class Producer(threading.Thread):

    def run(self):
        while True:
            elem = random.randrange(100)
            queue.put(elem)
            print "Producer a elem {}, Now size is {}".format(elem, queue.qsize())
            time.sleep(random.random())

class Consumer(threading.Thread):

    def run(self):
        while True:
            elem = queue.get()
            queue.task_done()
            print "Consumer a elem {}. Now size is {}".format(elem, queue.qsize())
            time.sleep(random.random())

后台线程

默认情况下，主线程退出后，子线程也会继续执行
如果希望子线程随主线程退出，使用 setDaemon(True)

t = MyThread()
        t.setDaemon(True)
        t.start()