Python进阶 - 进程与线程

1 Python下的进程编程

1.1 创建进程：

• system函数

原型如下：

system(command)

实际是调用系统内置的命令行程序来执行系统命令， 所以在命令结束之后会将控制权返回给Python进程。
如果返回0，说明执行成功，否则表示失败

• exec家族

共有8个类似函数：execl, execle, execlp, execv, execve, execvp, execvpe
exec函数执行完命令之后，将会接管Python进程， 而不会将控制权返回给Python进程。也就是说，Python进程会在调用exec函数之后终止。新生成的进程将会替换主进程。这些函数没有返回值，如果发生错误，将会触发OSError异常

1.2 终止进程

• sys.exit() 退出之前执行清理操作，更加优雅
• sys.abort() 直接发出终止信号，在exit不能终止程序的时候用这个。

2 多线程编程

2.1 Python多线程简介

Python使用全局解释器锁(GIL)来保证解释其中仅有一个线程，并在各个线程之间切换。当GIL可用的时候，处于就绪状态的线程在获取GIL之后就可以运行了。线程将在指定的间隔时间内运行，时间到之后重新进入就绪队列排队。当然，特定的事件可能导致中断。

Python提供了两种不同的方式：

• thread 低级的线程处理模块，仅提供最少的线程处理功能，在实际的代码中最好不要使用该模块
• threading 高级的线程处理模块，基于thread模块，部分思想来自于Java的thread类

多线程的协调：

threading模块中提供了数据同步的方法。Queue模块中，有一个同步的FIFO队列，特别适于多线程的同步。

2.2 生成和终止线程

thread模块

常用方法：

• start_new_thread 生成新线程，返回标识符的值
• exit 退出，触发一个 SystemExit 异常
• get_ident 获取标识符
• allocate_lock 加锁
• interrupt_main 在主线程中触发一个KeyboardInterrupt异常
• stack_size 返回堆栈大小

示例程序：

import _thread
import time


def hello(index):
    for v in range(5):
        time.sleep(2)
        print("线程", v, index)


def test():
    _thread.start_new_thread(hello, (1,))
    _thread.start_new_thread(hello, (2,))


test()
time.sleep(15)

threading.thread类

常用方法：

• start 允许进程实例
• run 实现自己的线程时需要重载此方法
• join 阻塞主线程，开始执行此线程
• getName 返回线程名
• setName 设置线程名
• isAlive 查看线程是否运行
• isDaemon 查看线程是否在后台运行
• setDaemon 设置线程后台运行

使用示例：

import threading


def z():
    print("线程名：" + threading.current_thread().getName())


t1 = threading.Thread(target=z, name="my")
t1.start()

自定义Thread(继承自threading.thread)：

import threading
import time
import random


class MyThread(threading.Thread):

    def __init__(self, name):
        threading.Thread.__init__(self, name=name)

    def run(self):
        for i in range(5):
            time.sleep(random.randint(1, 10))
            print("我是", self.name, "线程,第", i + 1, "次循环")


a = MyThread("A")
# a.setDaemon(True)
a.start()
b = MyThread("B")
# b.setDaemon(True)
b.start()
a.join()     # 加入join之后，先运行子线程，然后再执行之后的主线程代码！
b.join()
print("主线程退出，end！")

3 管理线程

线程状态转移：就绪、运行、休眠、终止

线程中的局部变量：

import threading
import random
import time


class ThreadLocal():
    def __init__(self):
        self.local = threading.local()

    def run(self):
        time.sleep(random.random())
        self.local.number = []
        for i in range(10):
            self.local.number.append(random.choice(range(10)))
        print(threading.currentThread(), self.local.number)


ThreadLocal = ThreadLocal()
threads = []
for i in range(5):
    t = threading.Thread(target = ThreadLocal.run)
    t.start()
    threads.append(t)
for i in range(5):
    threads[i].join()

另一种：

import threading
import random
import time


class ThreadLocal(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.local = threading.local()

    def run(self):
        time.sleep(random.random())
        self.local.number = []
        for i in range(10):
            self.local.number.append(random.choice(range(10)))
        print(threading.currentThread(), self.local.number)


threads = []
for i in range(5):
    t = ThreadLocal(str(i))
    t.start()
    threads.append(t)
for i in range(5):
    threads[i].join()

4 线程之间的同步

4.1 临界资源与临界区
4.2 锁机制

Lock:

import _thread
import time
mylock = _thread.allocate_lock()  # Allocate a lock
num = 0  # Shared resource


def add_num(name):
    global num
    while True:
        mylock.acquire()  # Get the lock
        # Do something to the shared resource
        print('Thread %s locked! num=%s' % (name, str(num)))
        if num >= 5:
            print('Thread %s released! num=%s' % (name, str(num)))
            mylock.release()
            num = 0
            _thread.exit_thread()
        num += 1
        print('Thread %s released! num=%s' % (name, str(num)))
        mylock.release()  # Release the lock.


def test():
    _thread.start_new_thread(add_num, ('A',))
    _thread.start_new_thread(add_num, ('B',))

if __name__ == '__main__':
    test()
    time.sleep(5)

RLock:

import threading
mylock = threading.RLock()
num = 0


class myThread(threading.Thread):

    def __init__(self, name):
        threading.Thread.__init__(self)
        self.t_name = name

    def run(self):
        global num  # 声明为全局变量
        while True:
            mylock.acquire()
            print('\nThread(%s) locked, Number: %d' % (self.t_name, num))
            if num >= 4:
                mylock.release()
                print('\nThread(%s) released, Number: %d' % (self.t_name, num))
                break
            num += 1
            print('\nThread(%s) released, Number: %d' % (self.t_name, num))
            mylock.release()


def test():
    thread1 = myThread('A')
    thread2 = myThread('B')
    thread1.start()
    thread2.start()

if __name__ == '__main__':
    test()

4.3 条件变量
4.4 信号量
4.5 同步队列

import threading
import queue    # Python3中将Queue改为了queue，千万注意！
import time
import random



class Worker(threading.Thread):
    def __init__(self, index, queue):
        threading.Thread.__init__(self)
        self.index = index
        self.queue = queue

    def run(self):
        while 1:
            time.sleep(random.random())
            item = self.queue.get()
            if item is None:
                break
            print("index", self.index, "task", item, "finished")
            self.queue.task_done()

q = queue.Queue()
for i in range(2):
    Worker(i, q).start()
for i in range(10):
    q.put(i)
for i in range(2):
    q.put(None)