python进程、线程

- 日理万妓 2021-12-12 20:29 301阅读 0赞

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

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()

输出结果如下：

![20190715112819776.png][]

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

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()

输出结果如下：

![20190715142237205.png][]

在进行出入库操作时，多线程并发时，会导致数据丢失问题。我们写一段代码，库存值为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()

输出结果如下：

![20190715151357968.png][]

运行结果与我们想象中的完全不一样，因为大部分线程启动的时候，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()

输入结果如下：

![20190715152714220.png][]

[20190715112819776.png]: /images/20211210/60e0727cb46845449b6305cd9124f386.png
[20190715142237205.png]: /images/20211210/5994a1a6a6254b6791def12dc2ced651.png
[20190715151357968.png]: /images/20211210/96ea5988f93848b788198e8d8a04b455.png
[20190715152714220.png]: /images/20211210/1ebf5af0c6a9494fa7f393a5be989f48.png