python多线程与多进程基础

一、python多线程的基本使用

1、多线程的调用方式：

①、直接调用：

# -*- coding:utf-8 -*-

import threading
import time


def run(args):
    print args
    time.sleep(1)
# 直接调用，target后面接线程启动的目标函数，args后面接目标函数的参数，必须以元组的形式
t = threading.Thread(target=run, args=('args', ))
# 启动子线程
t.start()

②、类调用（继承调用）：

# -*- coding:utf-8 -*-

import threading
import timedef controller(args):
    # 打印当前线程名
    print threading.current_thread().getName()
    # 打印当前活动的线程数
    print threading.active_count()
    print args
    time.sleep(1)


# 自定义线程类，并继承threading.Thread
class MyThread(threading.Thread):
    def __init__(self, args):
        # 封装调用controller函数的参数
        self.args = args
        # 使用父类的构造方法
        super(MyThread, self).__init__()

    # 重写线程调用时执行的run方法
    def run(self):
        controller(self.args)
        print 'controller函数执行了'

# 程序内打印__name__的值为__main__，程序外调用__name__的值为程序名
if __name__ == '__main__':
    # 实例化自定义的线程类
    t = MyThread('args')
    # 启动线程子线程
    t.start()

    print 'main thread running'

2、主线程的等待join方法和设置守护线程：

①、多线程的join（）方法：

前面的脚本运行后，你就会发现，子线程还没有执行完，主线程已经退出了，那么就做不到线程之间的数据同步；使用join方法，让主线程等待子线程全部退出后再执行自己的代码段：

# -*- coding:utf-8 -*-

import threading
import time
import sys


def controller(args):
    # 打印当前线程名
    print threading.current_thread().getName()
    # 打印当前活动的线程数
    print threading.active_count()
    print args
    time.sleep(1)


# 自定义线程类，并继承threading.Thread
class MyThread(threading.Thread):
    def __init__(self, args):
        # 封装调用controller函数的参数
        self.args = args
        # 使用父类的构造方法
        super(MyThread, self).__init__()

    # 重写线程调用时执行的run方法
    def run(self):
        controller(self.args)

# 程序内打印__name__的值为__main__，程序外调用__name__的值为程序名
if __name__ == '__main__':
    thread_pool = []
    for i in range(10):
        # 实例化自定义的线程类
        t = MyThread('args')
        # 把新创建的线程加入到线程池
        thread_pool.append(t)
        # 启动线程子线程
        t.start()
    for thread in thread_pool:
        # 主线程等待所有子线程退出
        thread.join()

    print 'main thread running'

②设置守护线程 setDaemon（）:

子线程设置为了守护线程就变成了主线程的仆人，主线程一停止，不管子线程是否执行完毕，都会被停止：

# -*- coding:utf-8 -*-

import threading
import time


def run(args):
    print args
    time.sleep(3)
    print '设置守护线程这里将不会执行'

# 直接调用，target后面接线程启动的目标函数，args后面接目标函数的参数，必须以元组的形式
t = threading.Thread(target=run, args=('args', ))

# 设置守护进行，主线程执行完毕后，子线程自动退出
t.setDaemon(True)
# 启动子线程
t.start()

time.sleep(1)
print 'main thread running...'

3、使用线程锁：

因为python多线程的全局解释器锁的存在，同一时间只有一个线程在执行，但是多个线程调用的时候，他们都会拷贝走一份数据，前一个线程未执行完，如果下一个线程就获得GIL锁的话，数据就会修改错误，所以在这里可以给每个线程在加一把锁，用于保护文件数据的修改：

# -*- coding:utf-8 -*-

import threading
import time


def run(args):
    # 获得锁
    # 程序执行到线程锁中间的代码段，每个线程都会等待上一个线程执行完毕
    lock.acquire()
    print args
    time.sleep(3)
    # 释放锁
    lock.release()
    print '设置守护线程这里将不会执行'

# 生成一把线程锁
lock = threading.Lock()

t = threading.Thread(target=run, args=('args', ))

# 启动子线程
t.start()
t.join()
time.sleep(1)
print 'main thread running...'

如果遇到要使用多把锁的情况，可以使用递归锁：

# -*- coding:utf-8 -*-

import threading
import time


def run(args):
    # 获得锁
    # 程序执行到线程锁中间的代码段，每个线程都会等待上一个线程执行完毕
    lock.acquire()
    print args
    run1('run1')
    time.sleep(3)
    # 释放锁
    lock.release()
    print '设置守护线程这里将不会执行'


def run1(args):
    # 获得锁
    # 程序执行到线程锁中间的代码段，每个线程都会等待上一个线程执行完毕
    lock.acquire()
    print args
    time.sleep(3)
    # 释放锁
    lock.release()
    print '设置守护线程这里将不会执行1'


# 生成一把递归线程锁
lock = threading.RLock()

t = threading.Thread(target=run, args=('args', ))

# 启动子线程
t.start()
t.join()
time.sleep(1)
print 'main thread running...'

4、信号量 Semaphore：

lock线程锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据；

# -*- coding:utf-8 -*-

import threading
import time


def run(args):
    # 获得锁
    # 程序执行到线程锁中间的代码段，每个线程都会等待上一个线程执行完毕
    semaphore.acquire()
    print args
    time.sleep(3)
    # 释放锁
    semaphore.release()

# 设置信号量
semaphore = threading.BoundedSemaphore(5)

for i in range(20):
    t = threading.Thread(target=run, args=('args', ))
    # 启动子线程
    t.start()

time.sleep(1)
print 'main thread running...'

 5、延时启动 Timer：

# -*- coding:utf-8 -*-

import threading
import time


def run(args):
    print args
    time.sleep(3)


for i in range(5):
    # 延时启动
    t = threading.Timer(3.0, run, args=('args', ))
    # 启动子线程
    t.start()

time.sleep(1)
print 'main thread running...'

6、Events 事件：

多线程中可以通过Event来实现两个或多个线程间的交互，通过event设置标志位，线程通过不断检测标志位是否被设定，来判断是否执行，因此可以用来调度多个线程的运行情况；

相关方法有：

# 创建一个事件的实例
event = threading.Event()

event.set()      # 设置标志位
event.clear()    # 清除标志位
event.wait()     # 等待标志位被设定
event.is_set()   # 判断标志位是否被设定

实例demo：

# -*- coding:utf-8 -*-

import threading
import time


def logcat(args):
    while True:
        if event.is_set():
            print '标志位被设定，线程运行。。。'
            time.sleep(1)
        else:
            print '标志位未被设定，等待中。。。'
            # 未检测到标志位，进行阻塞
            event.wait()


# 创建一个函数，用于控制标志位
def run():
    event.set()
    count = 0
    while True:
        if 5 < count < 10:
            event.clear()
        elif count > 10:
            event.set()
            count = 0
        count += 1
        time.sleep(1)


# 创建一个事件的实例
event = threading.Event()

t1 = threading.Thread(target=run,)
t2 = threading.Thread(target=logcat, args=('adb devices',))
t1.start()
t2.start()

 二、queue队列 

使用队列，进行线程间的通信；

1、实例化一个队列，并指定队列的长度：

# -*- coding:utf-8 -*-
import Queue

# 实例化一个队列，接受参数为队列的最大长度
q = Queue.Queue(maxsize=5)

2、往队列中添加数据：

q.put(1)  # 往队列中put数据，超过最大长度，则会阻塞，直到有数据被取出

3、从队列中取出数据：

q.get()  # 取出一条数据

4、查看队列的状态：

q.full()  # 判断队列是否已满，返回布尔值

q.empty()  # 判断队列是否为空，返回布尔值

q.qsize()  # 返回队列的长度

5、设置不同规则队列的：

①先入先出队列：

②、后入先出队列：

③、自定义出列顺序：

 三、多进程的基本使用

1、创建进程：

# -*- coding:utf-8 -*-

from multiprocessing import Process
import time
import os


def run():
    print 'process running'
    # 打印当前进程的进程号
    print os.getpid()
    time.sleep(2)

# windows启动多进程需要加下面这行
if __name__ == '__main__':
    # 创建一个进程
    p = Process(target=run,)
    p.start()
    p.join()
    print 'main process running '

2、进程间通讯：

①、进程的队列Queue：

# -*- coding:utf-8 -*-

from multiprocessing import Process, Queue
import time


def run(q):
    q.put(23)
    time.sleep(2)


if __name__ == '__main__':
    # 创建一个进程Q
    q = Queue(maxsize=5)
    '''通过参数进行传递队列，因为不同进程间的内存地址不相同，
    因此不能同时共享一份数据，这里是将创建的队列先序列化，传过去，再序列化传回来'''
    p = Process(target=run, args=(q, ))
    p.start()
    print q.get()

②、管道Pipe：

通过类似socket的方式进行数据的传递：

# -*- coding:utf-8 -*-

from multiprocessing import Process, Pipe


def run(p):
    text = p.recv()
    print text
    p.send('hello, father')


if __name__ == '__main__':
    # 新建一个管道，获得管道的两端，一端给子进程，一端父进程拿着
    father, son = Pipe()
    p = Process(target=run, args=(son, ))
    p.start()
    # 通过send和recv来接收，发送数据
    father.send('hello, son')
    print father.recv()

③、Managers 数据类型管理：

支持的数据类型： list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array. 

# -*- coding:utf-8 -*-

from multiprocessing import Process, Manager


def run(l1, d1):
    l1.append(10)
    d1['12'] = '23'


if __name__ == '__main__':
    # 创建一个进程间可以数据共享的对象
    manager = Manager()
    # 生成一个进程间可以数据共享的列表
    list1 = manager.list()
    # 生成一个进程间可以数据共享的字典
    dict1 = manager.dict()
    p = Process(target=run, args=(list1, dict1))
    p.start()
    p.join()
    print list1, dict1

3、进程池：

因为在windows上开多了进程，系统会爆炸的，所以需要有个进程池；

# -*- coding:utf-8 -*-


from multiprocessing import Process, Pool
import time


def f(i):
    time.sleep(1)
    return i


# 回调函数
def run(arg):
    print('-->callback:', arg)


if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        # 进程池，并可以指定父进程执行的回调函数
        pool.apply_async(func=f, args=(i,), callback=run)

    pool.close()
    pool.join()  # 进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。
    print('process run end')