一、操作系统/应用程序

  1. a. 硬件
  2.     - 硬盘
  3.     - CPU
  4.     - 主板
  5.     - 显卡
  6.     - 内存
  7.     - 电源
  8.     ...
  9. b. 装系统（软件）
  10.     - 系统就是一个由程序员写出来软件，该软件用于控制计算机的硬件，让他们之间进行相互配合。
  11.  
  12. c. 安软件（安装应用程序）
  13.     - QQ
  14.     - 百度云
  15.     - pycharm

二、并发和并行

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

三、线程和进程

  1. a. 单进程、单线程的应用程序
  1. print('')

最简单

  1. b. 到底什么是线程？什么是进程？
  2. 　　Python自己没有这玩意，Python中调用的操作系统的线程和进程。
  3.  
  4. c. 单进程、多线程的应用程序
  1. 　　一个应用程序（软件），可以有多个进程（默认只有一个），一个进程中可以创建多个线程（默认一个）
  1. import threading
  2. print('')
  3.  
  4. def func(arg):
  5.     print(arg)
  6. t = threading.Thread(target=func)
  7. t.start()
  8.  
  9. print('end')

代码

  1. d. 故事: Alex甄嬛西游传

　　总结：

　　　　1. 操作系统帮助开发者操作硬件。
　　　　2. 程序员写好代码在操作系统上运行（依赖解释器）。

  1. import threading
  2. import requests
  3. import uuid
  4.  
  5. url_list = [
  6.     'https://www3.autoimg.cn/newsdfs/g28/M05/F9/98/120x90_0_autohomecar__ChsEnluQmUmARAhAAAFES6mpmTM281.jpg',
  7.     'https://www2.autoimg.cn/newsdfs/g28/M09/FC/06/120x90_0_autohomecar__ChcCR1uQlD6AT4P3AAGRMJX7834274.jpg',
  8.     'https://www2.autoimg.cn/newsdfs/g3/M00/C6/A9/120x90_0_autohomecar__ChsEkVuPsdqAQz3zAAEYvWuAspI061.jpg',
  9. ]
  10.  
  11. def task(url):
  12.     ret = requests.get(url)
  13.     file_name = str(uuid.uuid4()) + '.jpg'
  14.     with open(file_name, mode='wb') as f:
  15.         f.write(ret.content)
  16.  
  17. for url in url_list:
  18.     task()
  19.  
  20. """
  21. - 你写好代码
  22. - 交给解释器运行： python s1.py
  23. - 解释器读取代码，再交给操作系统去执行，根据你的代码去选择创建多少个线程/进程去执行（单进程/单线程）。
  24. - 操作系统调用硬件：硬盘、cpu、网卡....
  25. """

以前的你，写代码：

  1. import threading
  2. import requests
  3. import uuid
  4.  
  5. url_list = [
  6.     'https://www3.autoimg.cn/newsdfs/g28/M05/F9/98/120x90_0_autohomecar__ChsEnluQmUmARAhAAAFES6mpmTM281.jpg',
  7.     'https://www2.autoimg.cn/newsdfs/g28/M09/FC/06/120x90_0_autohomecar__ChcCR1uQlD6AT4P3AAGRMJX7834274.jpg',
  8.     'https://www2.autoimg.cn/newsdfs/g3/M00/C6/A9/120x90_0_autohomecar__ChsEkVuPsdqAQz3zAAEYvWuAspI061.jpg',
  9. ]
  10.  
  11. def task(url):
  12.  
  13.     ret = requests.get(url)
  14.     file_name = str(uuid.uuid4()) + '.jpg'
  15.     with open(file_name, mode='wb') as f:
  16.         f.write(ret.content)
  17.  
  18. for url in url_list:
  19.  
  20.     t = threading.Thread(target=task,args=(url,))
  21.     t.start()
  22.  
  23. """
  24. - 你写好代码
  25. - 交给解释器运行： python s2.py
  26. - 解释器读取代码，再交给操作系统去执行，根据你的代码去选择创建多少个线程/进程去执行（单进程/4线程）。
  27. - 操作系统调用硬件：硬盘、cpu、网卡....
  28. """

现在的你，写代码：

  1.     Python多线程情况下：
  2.         - 计算密集型操作：效率低。（GIL锁）
  3.         - IO操作： 效率高 
  4.  
  5.     Python多进程的情况下：
  6.         - 计算密集型操作：效率高（浪费资源）。 不得已而为之。
  7.         - IO操作： 效率高 （浪费资源）。
  8.  
  9.     以后写Python时：
  10.         IO密集型用多线程： 文件/输入输出/socket网络通信
  11.         计算密集型用多进程。
  12.  
  13.     扩展：
  14.         Java多线程情况下：
  15.             - 计算密集型操作：效率高。
  16.             - IO操作： 效率高
  17.         Python多进程的情况下：
  18.             - 计算密集型操作：效率高（浪费资源）。
  19.             - IO操作： 效率高 浪费资源）。

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

  1. GIL锁，全局解释器锁。用于限制一个进程中同一时刻只有一个线程被cpu调度。
  2.  
  3. 扩展：默认GIL锁在执行100个cpu指令（过期时间）。

五、python线程编写

  1. # by luffycity.com
  2. import threading
  3.  
  4. # #################### 1. 计算密集型多线程无用 ####################
  5. # v1 = [11,22,33] # +1
  6. # v2 = [44,55,66] # 100
  7. #
  8. #
  9. # def func(data,plus):
  10. #     for i in range(len(data)):
  11. #         data[i] = data[i] + plus
  12. #
  13. # t1 = threading.Thread(target=func,args=(v1,1))
  14. # t1.start()
  15. #
  16. # t2 = threading.Thread(target=func,args=(v2,100))
  17. # t2.start()
  18.  
  19. # #################### 2. IO操作 多线程有用 ####################
  20. # import threading
  21. # import requests
  22. # import uuid
  23. #
  24. # url_list = [
  25. #     'https://www3.autoimg.cn/newsdfs/g28/M05/F9/98/120x90_0_autohomecar__ChsEnluQmUmARAhAAAFES6mpmTM281.jpg',
  26. #     'https://www2.autoimg.cn/newsdfs/g28/M09/FC/06/120x90_0_autohomecar__ChcCR1uQlD6AT4P3AAGRMJX7834274.jpg',
  27. #     'https://www2.autoimg.cn/newsdfs/g3/M00/C6/A9/120x90_0_autohomecar__ChsEkVuPsdqAQz3zAAEYvWuAspI061.jpg',
  28. # ]
  29. #
  30. # def task(url):
  31. #     ret = requests.get(url)
  32. #     file_name = str(uuid.uuid4()) + '.jpg'
  33. #     with open(file_name, mode='wb') as f:
  34. #         f.write(ret.content)
  35. #
  36. # for url in url_list:
  37. #
  38. #     t = threading.Thread(target=task,args=(url,))
  39. #     t.start()
  1. # by luffycity.com
  2. import threading
  3.  
  4. # ###################### 1.线程的基本使用 #################
  5. # def func(arg):
  6. #     print(arg)
  7. #
  8. #
  9. # t = threading.Thread(target=func,args=(11,))
  10. # t.start()
  11. #
  12. #
  13. # print(123)
  14. # ###################### 2.主线程默认等子线程执行完毕 #################
  15. # import time
  16. # def func(arg):
  17. #     time.sleep(arg)
  18. #     print(arg)
  19. #
  20. #
  21. # t1 = threading.Thread(target=func,args=(3,))
  22. # t1.start()
  23. #
  24. # t2 = threading.Thread(target=func,args=(9,))
  25. # t2.start()
  26. #
  27. # print(123)
  28. # ###################### 3.主线程不再等，主线程终止则所有子线程终止 #################
  29. # import time
  30. # def func(arg):
  31. #     time.sleep(2)
  32. #     print(arg)
  33. #
  34. # t1 = threading.Thread(target=func,args=(3,))
  35. # t1.setDaemon(True)
  36. # t1.start()
  37. #
  38. # t2 = threading.Thread(target=func,args=(9,))
  39. # t2.setDaemon(True)
  40. # t2.start()
  41. #
  42. # print(123)
  43.  
  44. # ###################### 4.开发者可以控制主线程等待子线程（最多等待时间） #################
  45. # import time
  46. # def func(arg):
  47. #     time.sleep(0.01)
  48. #     print(arg)
  49. #
  50. # print('创建子线程t1')
  51. # t1 = threading.Thread(target=func,args=(3,))
  52. # t1.start()
  53. # # 无参数，让主线程在这里等着，等到子线程t1执行完毕，才可以继续往下走。
  54. # # 有参数，让主线程在这里最多等待n秒，无论是否执行完毕，会继续往下走。
  55. # t1.join(2)
  56. #
  57. # print('创建子线程t2')
  58. # t2 = threading.Thread(target=func,args=(9,))
  59. # t2.start()
  60. # t2.join(2) # 让主线程在这里等着，等到子线程t2执行完毕，才可以继续往下走。
  61. #
  62. # print(123)
  63.  
  64. # ###################### 4.线程名称 #################
  65. # def func(arg):
  66. #     # 获取当前执行该函数的线程的对象
  67. #     t = threading.current_thread()
  68. #     # 根据当前线程对象获取当前线程名称
  69. #     name = t.getName()
  70. #     print(name,arg)
  71. #
  72. # t1 = threading.Thread(target=func,args=(11,))
  73. # t1.setName('侯明魏')
  74. # t1.start()
  75. #
  76. # t2 = threading.Thread(target=func,args=(22,))
  77. # t2.setName('刘宁钱')
  78. # t2.start()
  79. #
  80. # print(123)
  81.  
  82. # ###################### 5.线程本质 #################
  83. # 先打印：11？123？
  84. # def func(arg):
  85. #     print(arg)
  86. #
  87. # t1 = threading.Thread(target=func,args=(11,))
  88. # t1.start()
  89. # # start 是开始运行线程吗？不是
  90. # # start 告诉cpu，我已经准备就绪，你可以调度我了。
  91. # print(123)
  92.  
  93. # ###################### 6.补充：面向对象版本的多线程 #################
  94. # 多线程方式：1 (常见)
  95. # def func(arg):
  96. #     print(arg)
  97. #
  98. # t1 = threading.Thread(target=func,args=(11,))
  99. # t1.start()
  100.  
  101. # 多线程方式：2
  102. # class MyThread(threading.Thread):
  103. #
  104. #     def run(self):
  105. #         print(11111,self._args,self._kwargs)
  106. #
  107. # t1 = MyThread(args=(11,))
  108. # t1.start()
  109. #
  110. # t2 = MyThread(args=(22,))
  111. # t2.start()
  112.  
  113. print('end')

线程的使用

  1. # by luffycity.com
  2. import threading
  3.  
  4. # ###################### 1.线程的基本使用 #################
  5. # def func(arg):
  6. #     print(arg)
  7. #
  8. #
  9. # t = threading.Thread(target=func,args=(11,))
  10. # t.start()
  11. #
  12. #
  13. # print(123)
  14. # ###################### 2.主线程默认等子线程执行完毕 #################
  15. # import time
  16. # def func(arg):
  17. #     time.sleep(arg)
  18. #     print(arg)
  19. #
  20. #
  21. # t1 = threading.Thread(target=func,args=(3,))
  22. # t1.start()
  23. #
  24. # t2 = threading.Thread(target=func,args=(9,))
  25. # t2.start()
  26. #
  27. # print(123)
  28. # ###################### 3.主线程不再等，主线程终止则所有子线程终止 #################
  29. # import time
  30. # def func(arg):
  31. #     time.sleep(2)
  32. #     print(arg)
  33. #
  34. # t1 = threading.Thread(target=func,args=(3,))
  35. # t1.setDaemon(True)
  36. # t1.start()
  37. #
  38. # t2 = threading.Thread(target=func,args=(9,))
  39. # t2.setDaemon(True)
  40. # t2.start()
  41. #
  42. # print(123)
  43.  
  44. # ###################### 4.开发者可以控制主线程等待子线程（最多等待时间） #################
  45. # import time
  46. # def func(arg):
  47. #     time.sleep(0.01)
  48. #     print(arg)
  49. #
  50. # print('创建子线程t1')
  51. # t1 = threading.Thread(target=func,args=(3,))
  52. # t1.start()
  53. # # 无参数，让主线程在这里等着，等到子线程t1执行完毕，才可以继续往下走。
  54. # # 有参数，让主线程在这里最多等待n秒，无论是否执行完毕，会继续往下走。
  55. # t1.join(2)
  56. #
  57. # print('创建子线程t2')
  58. # t2 = threading.Thread(target=func,args=(9,))
  59. # t2.start()
  60. # t2.join(2) # 让主线程在这里等着，等到子线程t2执行完毕，才可以继续往下走。
  61. #
  62. # print(123)
  63.  
  64. # ###################### 4.线程名称 #################
  65. # def func(arg):
  66. #     # 获取当前执行该函数的线程的对象
  67. #     t = threading.current_thread()
  68. #     # 根据当前线程对象获取当前线程名称
  69. #     name = t.getName()
  70. #     print(name,arg)
  71. #
  72. # t1 = threading.Thread(target=func,args=(11,))
  73. # t1.setName('侯明魏')
  74. # t1.start()
  75. #
  76. # t2 = threading.Thread(target=func,args=(22,))
  77. # t2.setName('刘宁钱')
  78. # t2.start()
  79. #
  80. # print(123)
  81.  
  82. # ###################### 5.线程本质 #################
  83. # 先打印：11？123？
  84. # def func(arg):
  85. #     print(arg)
  86. #
  87. # t1 = threading.Thread(target=func,args=(11,))
  88. # t1.start()
  89. # # start 是开始运行线程吗？不是
  90. # # start 告诉cpu，我已经准备就绪，你可以调度我了。
  91. # print(123)
  92.  
  93. # ###################### 6.补充：面向对象版本的多线程 #################
  94. # 多线程方式：1 (常见)
  95. # def func(arg):
  96. #     print(arg)
  97. #
  98. # t1 = threading.Thread(target=func,args=(11,))
  99. # t1.start()
  100.  
  101. # 多线程方式：2
  102. # class MyThread(threading.Thread):
  103. #
  104. #     def run(self):
  105. #         print(11111,self._args,self._kwargs)
  106. #
  107. # t1 = MyThread(args=(11,))
  108. # t1.start()
  109. #
  110. # t2 = MyThread(args=(22,))
  111. # t2.start()
  112.  
  113. print('end')

多线程

  1. # by luffycity.com
  2. import time
  3. import threading
  4.  
  5. lock = threading.RLock()
  6.  
  7. n = 10
  8.  
  9. def task(i):
  10.     print('这段代码不加锁',i)
  11.  
  12.     lock.acquire() # 加锁，此区域的代码同一时刻只能有一个线程执行
  13.     global n
  14.     print('当前线程',i,'读取到的n值为：',n)
  15.     n = i
  16.     time.sleep(1)
  17.     print('当前线程',i,'修改n值为：',n)
  18.     lock.release() # 释放锁
  19.  
  20. for i in range(10):
  21.     t = threading.Thread(target=task,args=(i,))
  22.     t.start()

多线程问题

暂时忘记知识点

  1. import sys
  2.  
  3. v1 = sys.getcheckinterval()
  4. print(v1)

查看gil切换指令

  1. 总结：
  2. 1. 应用程序/进程/线程的关系？ *****（面试题：进程/线程/协程的区别？）
  3.  
  4. 2. 为什么要创建线程？
  5.     由于线程是cpu工作的最小单元，创建线程可以利用多核优势实现并行操作（Java/C#）。
  6.     注意：线程是为了工作。
  7.  
  8. 3. 为什么要创建进程？
  9.     进程和进程之间做数据隔离（Java/C#）。
  10.  
  11.     注意：进程是为了提供环境让线程工作。
  12.  
  13. 4. Python
    　　 IO操作不占用CPU
  14.     a. Python中存在一个GIL锁。 *****
  15.         - 造成：多线程无法利用多核优势。
  16.         - 解决：开多进程处理（浪费资源）
  17.         总结：
  18.             IO密集型：多线程
  19.             计算密集型：多进程
  20.     b. 线程的创建
  21.         - Thread         *****
  22.         - MyThread
  23.     c. 其他
  24.         - join             *****
  25.         - setDeanon        *****
  26.         - setName        *****
  27.         - threading.current_thread()    *****
  28.     d. 锁
  29.         - 获得
  30.         - 释放 
    　　6、线程创建的越多越好吗？
    　　　　不好，效率呈现抛物线形式
    　　　　线程之间进行切换时，要做上下文管理（操作费时）

day 32 操作系统、线程和进程（GIL锁）的更多相关文章

  1. [并发编程 - 多线程：信号量、死锁与递归锁、时间Event、定时器Timer、线程队列、GIL锁]

    [并发编程 - 多线程:信号量.死锁与递归锁.时间Event.定时器Timer.线程队列.GIL锁] 信号量 信号量Semaphore:管理一个内置的计数器 每当调用acquire()时内置计数器-1 ...

  2. 并发,并行,线程,进程,GIL锁

    1.并发和并行 并发: 同时做某些事,但是强调同一时段做多件事 如:同一路口,发生了车辆要同时通过路面的时间. 并行: 互不干扰的在同一时刻做多件事 如:同一时刻,同时有多辆车在多条车道上跑,即同时发 ...

  3. 多道技术 进程 线程 协程 GIL锁 同步异步 高并发的解决方案 生产者消费者模型

    本文基本内容 多道技术 进程 线程 协程 并发 多线程 多进程 线程池 进程池 GIL锁 互斥锁 网络IO 同步 异步等 实现高并发的几种方式 协程:单线程实现并发 一 多道技术 产生背景 所有程序串 ...

  4. 线程 Thread类 GIL锁 信号量 Event事件

    线程的开启方法 进程是操作系统调度的最小单位,一个进程最少有一个主线程,而一个进程中可以开启多个线程 from threading import Thread def task(): print('A ...

  5. python3 线程调用与GIL 锁机制

    转载

  6. 并发编程： GIL锁、GIL与互斥锁区别、进程池与线程池的区别

    一.GIL 二.关于GIL性能的讨论 三.计算密集测试 四.IO密集测试 五.GIL与互斥锁 六.TCP客户端 七.进程池 八.进程什么时候算是空闲 九.线程池 一.GIL GIL Global In ...

  7. GIL锁、进程池与线程池

    1.什么是GIL? 官方解释: ''' In CPython, the global interpreter lock, or GIL, is a mutex that prevents multip ...

  8. Python并发编程05 /死锁现象、递归锁、信号量、GIL锁、计算密集型/IO密集型效率验证、进程池/线程池

    Python并发编程05 /死锁现象.递归锁.信号量.GIL锁.计算密集型/IO密集型效率验证.进程池/线程池 目录 Python并发编程05 /死锁现象.递归锁.信号量.GIL锁.计算密集型/IO密 ...

  9. 线程守护进程与GIL

    为何要用多线程 多线程指的是,在一个进程中开启多个线程,简单的讲:如果多个任务共用一块地址空间,那么必须在一个进程内开启多个线程.详细的讲分为4点: 1. 多线程共享一个进程的地址空间 2. 线程比进 ...

  10. GIL锁,线程池

    内容梗概: 1.线程队列 2.线程池 3.GIL锁 1.线程队列 1.1先进先出队列(FIFO)import queueq = queue.Queue(3)q.put(1)q.put(2)q.put( ...

随机推荐

  1. 微软并发Key-Value存储库FASTER介绍

    微软支持并发的Key-Value 存储库有C++与C#两个版本.号称迄今为止最快的并发键值存储.下面是C#版本翻译: FASTER C#可在.NET Framework和.NET Core中运行,并且 ...

  2. 委托事件（jQuery）

    <div class="content"> <ul> <li>1</li> <li>2</li> <l ...

  3. Java基础（37）ArrayList的remove方法

    1.问题描述 给定两个字符串 s 和 t,它们只包含小写字母. 字符串 t 由字符串 s 随机重排,然后在随机位置添加一个字母. 请找出在 t 中被添加的字母. 输入: s = "abcd& ...

  4. （三）快速添加touch事件

    EasyTouch提供了类似UGUI的可视化点击事件,如button类似,此功能可以快速实现三维物体的旋转缩放.在场景中新建cube然后添加组件,输入quick会出现一下一个选项: quick dra ...

  5. Spring Boot项目在多环境下（开发、生产或测试环境）调用不同配置文件方式

    写在前面 最近由于项目要求,原先的项目只有开发环境的项目配置,后来不利于线上测试,于是,最近对于SpringBoot这部分多环境配置在网上查找了相关资料,并实现了配置,于是为了防止遗忘,特在此进行总结 ...

  6. 【问题记录】VMware Tools是灰色的，不能安装

    一.VMware Tools简介 VMware Tools 中包含一系列服务和模块,可在 VMware 产品中实现多种功能,从而使用户能够更好地管理客户机操作系统,以及与客户机操作系统进行无缝交互. ...

  7. BFM模型介绍及可视化实现（C++）

    BFM模型介绍及可视化实现(C++) BFM模型基本介绍 Basel Face Model是一个开源的人脸数据库,其基本原理是3DMM,因此其便是在PCA的基础上进行存储的. 目前有两个版本的数据库( ...

  8. 虚拟机linux centos7 查找ip不到的设置

    1.centos7 系统后查找ip信息,不用ifconfig -a 命令,开始使用ip Addr命令 输入ip Addr 命令后,并没有看到实际的ip地址,记住上述图片中红色标记的ens32 这个就是 ...

  9. 利用python的requests和BeautifulSoup库爬取小说网站内容

    1. 什么是Requests? Requests是用Python语言编写的,基于urllib3来改写的,采用Apache2 Licensed 来源协议的HTTP库. 它比urllib更加方便,可以节约 ...

  10. Resource Path Location Type Target runtime Apache Tomcat v6.0 is not defined(项目报错)已解决

    我换了开发工具后,导入的项目不是这里报错就是那里不错.不过,我喜欢.在tomcat里面部署项目后,定位到报错行时,总是提示我这句话:Description Resource Path Location ...