python 复习—并发编程系统并发线程和进程协程GIL锁CPU/IO密集型计算

Posted 2021-07-27 胖虎是只mao

并发编程前言：

  1、网络应用

       1）爬虫 直接应用并发编程；

       2）网络框架 django flask tornado 源码-并发编程

       3）socketserver 源码-并发编程

  2、运维领域

       1）自动化开发-运维开发（机器的批量管理，任务的批量执行等）

一、操作系统/应用程序

a、硬件

   - 硬盘

   - CPU

   - 主板

   - 显卡

   - 内存

   - 电源

   . . . . . .

b、装系统（软件）

   - 系统就是一个由程序员写出来的软件，该软件用于控制计算机的硬件，让他们之间进行相互配合。

c、安软件（安装应用程序）

   - QQ

   - 百度云

   - pycharm

   . . . . . .

二、并行与并发

并行是指两者同时执行（资源够用）
并发是指两者交替轮流使用资源（资源有限）

   并发，是伪的，由于执行速度特别快，人感觉不到停顿；

   并行，是真的，创建10个人同时操作；

   并行是指两者同时执行，比如赛跑，两个人都在不停的往前跑（资源够用，比如三个线程，四核的cpu）；

   并发是指资源有限的情况下，两者交替轮流使用资源，比如一段路（单核cpu资源）同时只能过一个人，A走一段后，让给B，B用完继续给A，交替使用，目的是提高效率；

区别：

并行是从微观上，也就是在一个精确的时间片刻，有不同的程序在执行，这就要求必须有多个处理器。

并发是从宏观上，在一个时间段上可以看成是同时执行的。

三、线程和进程

a、单进程、单线程的应用程序，比如：

print(‘666’)

b、到底什么是线程？什么是进程？

   python自己没有这玩意，python中调用的操作系统的线程和进程。

c、单进程、多线程的应用程序，比如：

	import threading
    print('666')

    def func(arg):
        print(arg)
    t = threading.Thread(target=func,args=(11,)) # 创建一个线程
    t.start()

一个应用程序（软件），可以有多个进程（默认只有一个），一个进程中可以创建多个线程（默认一个）。

总结：

   1）操作系统帮助开发者操作硬件；

   2）程序员写好代码在操作系统上运行（依赖解释器）；

   3）任务比较多时，可将以前代码写法作如下改进

以前的我们写代码：

	import requests
    import uuid

    url_list = [
'https://www3.autoimg.cn/newsdfs/g28/M05/F9/98/120x90_0_autohomecar__ChsEnluQmUmARAhAAAFES6mpmTM281.jpg',
'https://www2.autoimg.cn/newsdfs/g28/M09/FC/06/120x90_0_autohomecar__ChcCR1uQlD6AT4P3AAGRMJX7834274.jpg',
'https://www2.autoimg.cn/newsdfs/g3/M00/C6/A9/120x90_0_autohomecar__ChsEkVuPsdqAQz3zAAEYvWuAspI061.jpg',
    ]

    def task(url):
        ret = requests.get(url)
        file_name = str(uuid.uuid4()) + '.jpg'
        with open(file_name, mode='wb') as f:
            f.write(ret.content)

    for url in url_list:
        task()
    """
    - 我们写好代码
    - 交给解释器运行： python s1.py 
    - 解释器读取代码，再交给操作系统去执行，根据我们的代码去选择创建多少个线程/进程去执行（此程序是单进程/单线程）。
    - 操作系统调用硬件：硬盘、cpu、网卡....
    """

现在的我们写代码

	import threading
    import requests
    import uuid

    url_list = [
'https://www3.autoimg.cn/newsdfs/g28/M05/F9/98/120x90_0_autohomecar__ChsEnluQmUmARAhAAAFES6mpmTM281.jpg',
'https://www2.autoimg.cn/newsdfs/g28/M09/FC/06/120x90_0_autohomecar__ChcCR1uQlD6AT4P3AAGRMJX7834274.jpg',
'https://www2.autoimg.cn/newsdfs/g3/M00/C6/A9/120x90_0_autohomecar__ChsEkVuPsdqAQz3zAAEYvWuAspI061.jpg',
    ]

    def task(url):
        ret = requests.get(url)
        file_name = str(uuid.uuid4()) + '.jpg'
        with open(file_name, mode='wb') as f:
            f.write(ret.content)

    for url in url_list:
        t = threading.Thread(target=task, args=(url,)) # 创建线程
        t.start()
    """
    - 你写好代码
    - 交给解释器运行： python s2.py 
    - 解释器读取代码，再交给操作系统去执行，根据你的代码去选择创建多少个线程/进程去执行（此程序是单进程/4线程）。
    - 操作系统调用硬件：硬盘、cpu、网卡....
    """

四、python中线程和进程（GIL锁）

GIL锁：python内置的一个全局解释器锁。用于限制一个进程中同一时刻只有一个线程被cpu调度。

扩展：默认GIL锁再执行100个cpu指令（过期时间）。

    import sys
    v = sys.getcheckinterval()
    print(v)  # 100

题1：为什么有这把GIL锁？

python语言的创始人在开发这门语言时，目的是快速把语言开发出来，如果加上GIL锁（c语言加锁），切换时按照100条字节指令来进行线程间的切换。

问题2：进程和线程的区别？

线程，线程是cpu工作的最小单元；

进程，进程是cpu资源分配的最小单元，为线程提供一个资源共享的空间；

一个进程中可以有多个线程，一个进程中默认有一个主线程；

对于python来说，它的进程和线程和其他语言有差异，有GIL锁。它保证一个进程中同一时刻只有一个线程被cpu调度；

IO密集型操作可以使用多线程，（大部分情况是IO密集，主要包括网络、磁盘IO）
计算密集型可以使用多进程；（计算密集主要消耗CPU资源）

问题3：线程创建的越多越好吗？

不是，线程之间进行切换，要做上下文管理。

五、python线程编写

1、线程的基本使用，如下示例：

	import threading
　　def func(arg):
    　　print(arg)

　　t = threading.Thread(target=func,args=(11,)) # 创建一个子线程
　　t.start()

　　print(123)
　　# 11
　　# 123　　# 程序结束

2、主线程默认等子线程执行完毕，才结束程序，如下示例：

	import threading
    import time
    def func(arg):
        time.sleep(arg)
        print(arg)

    t1 = threading.Thread(target=func,args=(3,))
    t1.start()

    t2 = threading.Thread(target=func,args=(6,))
    t2.start()
    # 3  # 程序开始3秒后
    # 6  # 程序开始6秒后
    # 程序结束

3、主线程不再等，当主线程终止则所有子线程也终止，使用setDaemon(True)，如下示例：

	import threading
    import time
    def func(arg):
        time.sleep(arg)
        print(arg)

    t1 = threading.Thread(target=func,args=(3,))
    t1.setDaemon(False)  # 主线程等待此子进程
    t1.start()

    t2 = threading.Thread(target=func,args=(6,))
    t2.setDaemon(True)  # 主线程不再等待此子进程
    t2.start()

    print(123)
    # 123
    # 3
    # # 程序结束

4、开发者可以控制主线程等待子线程（最多等待时间），使用join(n)，如下示例：

	import threading
    import time
    def func(arg):
        time.sleep(arg)
        print(arg)

    print('创建子线程t1')
    t1 = threading.Thread(target=func,args=(3,))
    t1.start()
    t1.join(2)
    # 无参数，让主线程在这里等着，等到子线程t1执行完毕，才可以继续往下走。
    # 有参数，让主线程在这里最多等待n秒，无论是否执行完毕，会继续往下走。

    print('创建子线程t2')
    t2 = threading.Thread(target=func,args=(1,))
    t2.start()
    t2.join(3) # 让主线程在这里等着，最多等待3秒，会继续往下走，
    # 若子线程t2不到3秒就执行完毕，则子线程执行完毕主线程就往下走。

    print(123)
    # 创建子线程t1
    # 创建子线程t2
    # 3
    # 1
    # 123
    # 程序结束

5、线程名称，如下示例：

	import threading
    def func(arg):
        t = threading.current_thread()  # 获取当前执行该函数的线程的对象
        name = t.getName()  # 根据当前线程对象获取当前线程名称
        print(name,arg)

    t1 = threading.Thread(target=func,args=(11,))
    t1.setName('郭德纲')  # 设置线程名称
    t1.start()

    t2 = threading.Thread(target=func,args=(22,))
    t2.setName('孙红雷')  # 设置线程名称
    t2.start()

    print(123)
    # 郭德纲 11
    # 孙红雷 22
    # 123

7、面向对象版本的多线程，如下示例：

常见创建多线程的方式：

	import threading
    def func(arg):
        print(arg)

    t1 = threading.Thread(target=func,args=(11,))
    t1.start()

	import threading
    class MyThread(threading.Thread):
        def run(self):
            print(11111,self._args,self._kwargs)

    t1 = MyThread(args=(11,))
    t1.start()  # 在cpu内部，如果要调度这个线程的话会执行这个对象的run方法

    t2 = MyThread(args=(22,))
    t2.start()

    print('end')
    # 11111 (11,) {}
    # 11111 (22,) {}
    # end

面向对象方式（一般不用，了解即可）：

8、多线程

1）计算密集型多线程无用，如下示例：

	import threading
    v1 = [11,22,33] # +1
    v2 = [44,55,66] # +100

    def func(data,plus):
        for i in range(len(data)):
            data[i] = data[i] + plus

    t1 = threading.Thread(target=func,args=(v1,1))
    t1.start()

    t2 = threading.Thread(target=func,args=(v2,100))
    t2.start()

2）IO操作，多线程有用（IO操作不占用cpu），如“三、线程和进程”中创建多个线程的代码示例；

9、多线程的问题（加锁+释放锁）

	import time
    import threading

    lock = threading.RLock()

    n = 10

    def task(i):
        print('这段代码不加锁',i)

        lock.acquire() # 加锁，此区域的代码同一时刻只能有一个线程执行
        global n
        print('当前线程',i,'读取到的n值为：',n)
        n = i
        time.sleep(1)
        print('当前线程',i,'修改n值为：',n)
        lock.release() # 释放锁

    for i in range(10):
        t = threading.Thread(target=task,args=(i,))
        t.start()

总结：

   1. 应用程序/进程/线程的关系？ *****（面试题：进程/线程/协程的区别？）

         

   2. 为什么要创建线程？

          由于线程是cpu工作的最小单元，创建线程可以利用多核优势实现并行操作（Java/C#）。

          注意：线程是为了工作。

                

   3. 为什么要创建进程？

          进程和进程之间做数据隔离（Java/C#）。

                

          注意：进程是为了提供环境让线程工作。

                

   4. Python

          a. Python中存在一个GIL锁    *****

                 - 造成：多线程无法利用多核优势。

                 - 解决：开多进程处理（浪费资源）

                 进程和线程的使用准则：

                        IO密集型：多线程

                        计算密集型：多进程

          b. 线程的创建

                 - Thread             *****

                 - MyThread

          c. 其他

                 - join                  *****

                 - setDaemon      *****

                 - setName           *****

                 - threading.current_thread()  *****

          d. 锁

                 - 获得

                 - 释放

进程、线程、协程区别：

python 多线程只能同时使用一个CPU，但是多线程也能用于IO 的密集型计算，因为CPU和IO是可以并行进行的。而进程只能同时使用单个CPU，多进程就可以同时利用多核CPU

GIL锁

GIL 使得同一时刻只有一个线程在执行，其他线程在等待，类似于并发

如果不加锁，多线程执行的过程中，python引用计数器发生混乱

使用 multiprocessing 多进程机制，实现多核CPU优势， 适用于CPU密集型计算
多线程 threading多线程机制，适用于 IO 密集型计算