day32

一、操作系统/应用程序

a. 硬件
  - 硬盘
  - CPU
  - 主板
  - 显卡
  - 内存条
  - 电源
  ...
b. 装系统(软件)
  - 系统就是一个由程序员写出来的软件, 该软件用于控制计算机的硬件, 让他们之间相互配合.
c. 装软件(安装应用程序)
  - QQ
  - 百度云
  - pycharm
  ...

二、并发和并行

并发, 伪 由于执行速度特别快, 人感觉不到停顿
并行, 真 创建10个人同时操作.

并行:指在同一时刻,有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看,二者都是一起执行的。
并发:并发是指资源有限的情况下,两者交替轮流使用资源,比如一个单核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)
    t.start()

一个应用程序(软件),可以有多个进程(默认只有一个),一个进程中可以创建多个线程(默认一个)。

d. 故事: Alex甄嬛西游传

总结:
  1. 操作系统帮助开发者操作硬件。
  2. 程序员写好代码在操作系统上运行(依赖解释器)。
  3.当任务特别多,我们可以把以前的写法改进一下:

day32
    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:
        task(url)

    """
    - 你写好代码
    - 交给解释器运行: python s1.py 
    - 解释器读取代码,再交给操作系统去执行,根据你的代码去选择创建多少个线程/进程去执行(单进程/单线程)。
    - 操作系统调用硬件:硬盘、cpu、网卡....
    """
以前的我们写代码 day32
    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锁(全局解释器锁): 用于限制一个进程中同一时刻只有一个线程被cpu调度。
扩展:默认GIL锁再执行100个cpu指令(过期时间)切换线程。

day32查看方法

线程和进程的区别:
  线程,线程是cpu工作的最小单元;
  进程,进程是cpu资源分配的最小单元,为线程提供一个资源共享的空间;
  一个进程中可以有多个线程,一个进程中默认有一个主线程;

Python多线程情况下:
  - 计算密集型操作:效率低。(GIL锁)
  - IO操作:效率高

Python多进程的情况下:
  - 计算密集型操作:效率高(浪费资源)。 不得已而为之。
  - IO操作:效率高 (浪费资源)。

以后写Python时:
  IO密集型用多线程: 文件/输入输出/socket网络通信
  计算密集型用多进程。

扩展:
  Java多线程情况下:
    - 计算密集型操作:效率高。
    - IO操作: 效率高
  Python多进程的情况下:
    - 计算密集型操作:效率高(浪费资源)。
    - IO操作: 效率高 (浪费资源)。

五、线程的使用

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=(9,))
    t2.start()

    print(123)
    
    # 3  # 程序开始3秒后
    # 6  # 程序开始6秒后
    # 程序结束

3、主线程不再等,当主线程终止则所有子线程也终止,使用setDaemon(True)

    import threading
    import time
    def func(arg):
        time.sleep(2)
        print(arg)
    
    t1 = threading.Thread(target=func,args=(3,))
    t1.setDaemon(False)  # 主线程等待此子进程(默认是False等待)
    t1.start()
    
    t2 = threading.Thread(target=func,args=(9,))
    t2.setDaemon(True)  # 主线程等待此子进程(需要设置)
    t2.start()
    
    print(123)

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执行完毕,才可以往下走.
    # 有参数: 让主线程在这里最多等n秒,无论是否执行完毕,会继续往下走.
    t1.join(2)
    
    print("创建子线程t2")
    t2 = threading.Thread(target=func,args=(1,))
    t2.start()
    t2.join(3)  # 让主线程在这里等着,最多等待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

6、线程本质

   # 先打印:11?123?
    import threading
    def func(arg):
        print(arg)

    t1 = threading.Thread(target=func,args=(11,))
    t1.start()
    # start 是开始运行线程吗?不是
    # start 告诉cpu,我已经准备就绪,你可以调度我了。
    print(123)

7、补充: 面向对象版本的多线程

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

    t1 = threading.Thread(target=func,args=(11,))
    t1.start()
常见的创建多线程的方式 day32
    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
面对对象方式(一般不用,了解即可))

六、Python中线程编写

1. 计算密集型多线程无用

    impot 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操作,多线程有用

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

3. 多线程的问题(加锁和释放锁)

    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    *****
      - MyTread
    c. 其他
      - join          *****
      - setDeanon   *****
      - setName      *****
      - threading.current_thread()   *****
    d. 锁
      - 加锁
      - 释放

上一篇:day32 连接/通信循环和粘包问题


下一篇:day32