python进程、线程

为什么编程的时候要使用进程、线程、协程？使用它们是为了进行多并发编程。那么为什么要进行多并发编程？因为多并发编程可以减少程序运行的时间，让用户获得更好的体验。

1.进程

概念：操作系统执行程序分配存储空间的最小单位。一个CPU只能同时处理一个进程。python实现多进程，使用multiprocessing模块的Process类来创建进程。具体代码如下：

from multiprocessing import Process
from os import getpid
import time
from random import randint

def download(filename):
    """
    定义一个下载文件的方法
    :param filename:要下载的文件名
    :return:
    """
    task = randint(8, 15)
    time.sleep(task)
    print("下载文件：%s，花费%s秒"%(filename,task))

def main():
    #记录开始下载时间
    start = time.time()
    #创建一个进程，target为进程要执行的方法，args是一个元组，为调用该方法要传入的参数。
    p1 = Process(target=download,args=("python自动化测试.pdf",))
    #启动进程
    p1.start()
    p2 = Process(target=download,args=("测试技巧.pdf",))
    p2.start()
    #执行进程并等待进程执行结束
    p1.join()
    p2.join()
    #记录下载完成时间
    end = time.time()
    #输出下载总耗时
    print("下载总耗时%.2f秒"%(end-start))

if __name__  == "__main__":
    main()

输出结果如下：

使用多进程的编程的好处是可以大大提高代码的执行效率，但是多进程存在一个问题，进程之前的通信比较复杂，实现起来会占用较大的资源，此时我们引入线程的来解决这个问题。

2.线程

一个进程可以包含多个线程，同一进程中的每个线程的信息是可以进行共享的。python使用threading模块的Thread类来创建新的线程。python的类是可以继承的，我们创建类时可以继承Thread类。具体代码如下：

from threading import Thread
from random import randint
import time

#创建Download类，继承Thread类
class Download(Thread):

    def __init__(self, filename):
        super().__init__()
        self._filename = filename

    def run(self):
        task = randint(8, 13)
        time.sleep(task)
        print("下载文件：%s，花费%s秒"%(self._filename,task))

    def close(self):
        print("3sdf%s"%self._filename)

def main():
    start = time.time()
    t1 = Download("python自动化测试.pdf")
    #执行t1.start时，会运行run方法
    t1.start()
    t2 = Download("测试技巧.pdf")
    t2.start()
    t1.join()
    t2.join()
    end = time.time()
    print("下载完成，共耗时%.2f"%(end-start))

if __name__ == "__main__":
    main()

输出结果如下：

在进行出入库操作时，多线程并发时，会导致数据丢失问题。我们写一段代码，库存值为100，启动50个线程同时进行入库操作，所有线程入库结束后。理论上最终的库存值为150。具体代码如下：

from threading import Thread
from random import randint
import time

class Repertory(object):
    "创建仓库类"
    def __init__(self):
        #初始化仓库数量
        self._initialize_number = 100

    def add_number(self,number):
        #入库操作
        new_number = number+self._initialize_number
        #模拟入库时间
        time.sleep(0.01)
        #更新仓库库存
        self._initialize_number = new_number
    @property
    def number(self):
        #返回仓库库存数量
        return self._initialize_number


class AddNumberThread(Thread):

    def __init__(self, repertory, number):
        """

        :param repertory: 仓库对象
        :param number: 新增库存数量
        """
        super().__init__()
        self._repertory = repertory
        self._number = number

    def run(self):
        self._repertory.add_number(number=self._number)


def main():
    repertory = Repertory()
    threads = []
    #创建50个线程进行入库操作
    for _ in range(50):
        t = AddNumberThread(repertory=repertory,number=1)
        threads.append(t)
        t.start()
    #等待所有线程入库结束
    for thread in threads:
        thread.join()
    #打印最终的库存数
    print("仓库库存数%s"%repertory.number)

if __name__ == "__main__":
    main()

输出结果如下：

运行结果与我们想象中的完全不一样，因为大部分线程启动的时候，self._initialize_number都等于100，要解决这个问题，就需要用到线程锁。在代码中加入锁，修改后的代码如下：

from threading import Thread, Lock
import time

class Repertory(object):
    "创建仓库类"
    def __init__(self):
        #初始化仓库数量
        self._initialize_number = 100
        #定义锁
        self._lock = Lock()

    def add_number(self,number):
        #拿到锁才能执行下面代码
        self._lock.acquire()
        try:
            #入库操作
            new_number = number+self._initialize_number
            #模拟入库时间
            time.sleep(0.01)
            #更新仓库库存
            self._initialize_number = new_number
        finally:
            #代码执行完成后，释放锁
            self._lock.release()
    @property
    def number(self):
        #返回仓库库存数量
        return self._initialize_number


class AddNumberThread(Thread):

    def __init__(self, repertory, number):
        """

        :param repertory: 仓库对象
        :param number: 新增库存数量
        """
        super().__init__()
        self._repertory = repertory
        self._number = number

    def run(self):
        self._repertory.add_number(number=self._number)


def main():
    repertory = Repertory()
    threads = []
    #创建50个线程进行入库操作
    for _ in range(50):
        t = AddNumberThread(repertory=repertory,number=1)
        threads.append(t)
        t.start()
    #等待所有线程入库结束
    for thread in threads:
        thread.join()
    #打印最终的库存数
    print("仓库库存数%s"%repertory.number)

if __name__ == "__main__":
    main()

输入结果如下：