这节内容主要是关于线程的学习

首先要了解的什么是进程,什么是线程

进程与线程

什么是进程(process)?

程序并不能单独运行,只有将程序装载到内存中,系统为它分配资源才能运行,而这种执行的程序就称之为进程。程序和进程的区别就在于:程序是指令的集合,它是进程运行的静态描述文本;进程是程序的一次执行活动,属于动态概念。

在多道编程中,我们允许多个程序同时加载到内存中,在操作系统的调度下,可以实现并发地执行。这是这样的设计,大大提高了CPU的利用率。进程的出现让每个用户感觉到自己独享CPU,因此,进程就是为了在CPU上实现多道编程而提出的。

有了进程为什么还要线程?

进程有很多优点,它提供了多道编程,让我们感觉我们每个人都拥有自己的CPU和其他资源,可以提高计算机的利用率。很多人就不理解了,既然进程这么优秀,为什么还要线程呢?其实,仔细观察就会发现进程还是有很多缺陷的,主要体现在两点上:

  • 进程只能在一个时间干一件事,如果想同时干两件事或多件事,进程就无能为力了。

  • 进程在执行的过程中如果阻塞,例如等待输入,整个进程就会挂起,即使进程中有些工作不依赖于输入的数据,也将无法执行。

例如,我们在使用qq聊天, qq做为一个独立进程如果同一时间只能干一件事,那他如何实现在同一时刻 即能监听键盘输入、又能监听其它人给你发的消息、同时还能把别人发的消息显示在屏幕上呢?你会说,操作系统不是有分时么?但我的亲,分时是指在不同进程间的分时呀, 即操作系统处理一会你的qq任务,又切换到word文档任务上了,每个cpu时间片分给你的qq程序时,你的qq还是只能同时干一件事呀。

再直白一点, 一个操作系统就像是一个工厂,工厂里面有很多个生产车间,不同的车间生产不同的产品,每个车间就相当于一个进程,且你的工厂又穷,供电不足,同一时间只能给一个车间供电,为了能让所有车间都能同时生产,你的工厂的电工只能给不同的车间分时供电,但是轮到你的qq车间时,发现只有一个干活的工人,结果生产效率极低,为了解决这个问题,应该怎么办呢?。。。。没错,你肯定想到了,就是多加几个工人,让几个人工人并行工作,这每个工人,就是线程!

什么是线程(thread)?

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务

进程与线程的区别?

  1. Threads share the address space of the process that created it; processes have their own address space.
  2. Threads have direct access to the data segment of its process; processes have their own copy of the data segment of the parent process.
  3. Threads can directly communicate with other threads of its process; processes must use interprocess communication to communicate with sibling processes.
  4. New threads are easily created; new processes require duplication of the parent process.
  5. Threads can exercise considerable control over threads of the same process; processes can only exercise control over child processes.
  6. Changes to the main thread (cancellation, priority change, etc.) may affect the behavior of the other threads of the process; changes to the parent process does not affect child processes.

Python GIL(Global Interpreter Lock)  

无论你启多少个线程,你有多少个cpu, Python在执行的时候会淡定的在同一时刻只允许一个线程运行。

首先需要明确的一点是GIL并不是Python的特性,它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言(语法)标准,但是可以用不同的编译器来编译成可执行代码。有名的编译器例如GCC,INTEL C++,Visual C++等。Python也一样,同样一段代码可以通过CPython,PyPy,Psyco等不同的Python执行环境来执行。像其中的JPython就没有GIL。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python,也就想当然的把GIL归结为Python语言的缺陷。所以这里要先明确一点:GIL并不是Python的特性,Python完全可以不依赖于GIL

这篇文章透彻的剖析了GIL对python多线程的影响,强烈推荐看一下:http://www.dabeaz.com/python/UnderstandingGIL.pdf

Python threading模块

  1. #Author:Ivor
  2. import threading
  3. import time
  4. def run(n):
  5. print("task---start,",n)
  6. time.sleep(1)
  7. print("task---end",n,threading.current_thread())
  8. res_list = []
  9. start_time = time.time()
  10.  
  11. #Starting Multiple threads
  12. for i in range(50):
  13. t = threading.Thread(target=run,args=("t %s" % i,))
  14. #set child threads to daemon threads
  15. t.setDaemon(True)
  16. t.start()
  17. res_list.append(t)
  18.  
  19. #Main Thread waiting for the child threads
  20. for r in res_list:
  21. r.join()
  22.  
  23. print("current thread",threading.current_thread())
  24. print("Running time = ",time.time() - start_time)
  25.  
  26. import threading
  27.  
  28. class MyThread(threading.Thread):
  29. def __init__(self, num):
  30. threading.Thread.__init__(self)
  31. self.num = num
  32.  
  33. def run(self): # 定义每个线程要运行的函数
  34. print("running on number:%s" % self.num)
  35. time.sleep(3)
  36.  
  37. if __name__ == '__main__':
  38. t1 = MyThread(1)
  39. t2 = MyThread(2)
  40. t1.start()
  41. t2.start()

线程锁(互斥锁Mutex)

  1. #Authon Ivor
  2. import time
  3. import threading
  4.  
  5. def addNum():
  6. global num # 在每个线程中都获取这个全局变量
  7. lock.acquire()
  8. num -= 1 # 对此公共变量进行-1操作
  9. lock.release()
  10. num = 100 # 设定一个共享变量
  11. thread_list = []
  12. lock = threading.Lock()
  13. for i in range(100):
  14. t = threading.Thread(target=addNum)
  15. t.start()
  16. thread_list.append(t)
  17. for t in thread_list: # 等待所有线程执行完毕
  18. t.join()
  19.  
  20. print('final num:', num)

RLock(递归锁)

  1. #Authon Ivor
  2.  
  3. import threading, time
  4.  
  5. def run1():
  6. print("grab the first part data")
  7. lock.acquire()
  8. global num
  9. num += 1
  10. lock.release()
  11. return num
  12.  
  13. def run2():
  14. print("grab the second part data")
  15. lock.acquire()
  16. global num2
  17. num2 += 1
  18. lock.release()
  19. return num2
  20.  
  21. def run3():
  22. lock.acquire()
  23. res = run1()
  24. print('--------between run1 and run2-----')
  25. res2 = run2()
  26. lock.release()
  27. print(res, res2)
  28.  
  29. num, num2 = 0, 0
  30.  
  31. lock = threading.RLock() #must be use RLock
  32. # lock = threading.Lock()
  33. for i in range(10):
  34. t = threading.Thread(target=run3)
  35. t.start()
  36.  
  37. while threading.active_count() != 1:
  38. print(threading.active_count())
  39. else:
  40. print('----all threads done---')
  41. print(num, num2)

Semaphore(信号量)

  1. #Authon Ivor
  2. import threading
  3. import time
  4.  
  5. def run(n):
  6. semaphore.acquire()
  7. print(n)
  8. time.sleep(1)
  9. semaphore.release()
  10.  
  11. neq = threading.Semaphore(5)
  12. semaphore = threading.BoundedSemaphore(5)
  13. for i in range(10):
  14. t = threading.Thread(target=run,args=(i,))
  15. t.start()

Events

  1. #Authon Ivor
  2. import threading
  3. import time
  4.  
  5. def light():
  6. count = 0
  7. #initialize signal
  8. cond.set()
  9. while True:
  10. if count > 5 and count < 10:
  11. #clear signal
  12. cond.clear()
  13. print("\033[41;1mRed light\033[;0m")
  14. elif count > 10:
  15. #set signal
  16. cond.set()
  17. count = 0
  18. else:
  19. print("\033[42;1mGreen light\033[;0m")
  20. count += 1
  21. time.sleep(1)
  22.  
  23. def car():
  24. while True:
  25. time.sleep(1)
  26. if cond.is_set():
  27. print("Car gogo...")
  28. else:
  29. print("Car stop...")
  30. #hang on the thread
  31. cond.wait()
  32.  
  33. cond = threading.Event()
  34. l = threading.Thread(target=light)
  35. c = threading.Thread(target=car)
  36. l.start()
  37. c.start()

不得不提的消息队列

Queue

  1. #Authon Ivor
  2. import threading
  3. import queue
  4.  
  5. def producer():
  6. for i in range(10):
  7. q.put("骨头 %s" % i)
  8. print("开始等待所有的骨头被取走...")
  9. q.join()
  10. print("所有的骨头被取完了...")
  11.  
  12. def consumer(n):
  13. while q.qsize() > 0:
  14. print("%s 取到" % n, q.get())
  15. q.task_done() # 告知这个任务执行完了
  16.  
  17. q = queue.Queue()
  18. p = threading.Thread(target=producer)
  19. p.start()
  20. c1 = consumer("李闯")
  21.  
  22. import time,random
  23. import queue,threading
  24.  
  25. def Producer(name):
  26. count = 0
  27. while count <20:
  28. time.sleep(random.randrange(3))
  29. q.put(count)
  30. print('Producer %s has produced %s baozi..' %(name, count))
  31. count +=1
  32.  
  33. def Consumer(name):
  34. count = 0
  35. while count <20:
  36. time.sleep(random.randrange(4))
  37. if not q.empty():
  38. data = q.get()
  39. print(data)
  40. print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data))
  41. else:
  42. print("-----no baozi anymore----")
  43. count +=1
  44.  
  45. q = queue.Queue()
  46. p1 = threading.Thread(target=Producer, args=('A',))
  47. c1 = threading.Thread(target=Consumer, args=('B',))
  48. p1.start()
  49. c1.start()

还有一个实现自动化运维的模块

Pamamiko

SFTP

  1. #Authon Ivor
  2. import paramiko
  3. #创建一个连接
  4. conn = paramiko.Transport(('10.0.2.57',22))
  5. conn.connect(username='root',password='test83@123')
  6. #通过连接实例,创建一个FTPClient实例
  7. sftp = paramiko.SFTPClient.from_transport(conn)
  8. #上传动作
  9. # sftp.put('D:\\test.xls','/tmp/test.xls')
  10. #下载动作
  11. # sftp.get('/tmp/test.xls','D:\\test.xls')
  12. conn.close()
  13.  
  14. #Author:Ivor
  15. import paramiko
  16.  
  17. private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')
  18. transport = paramiko.Transport(('hostname', 22))
  19. transport.connect(username='wupeiqi', pkey=private_key)
  20. sftp = paramiko.SFTPClient.from_transport(transport)
  21.  
  22. sftp.put('/tmp/location.py', '/tmp/test.py')
  23.  
  24. sftp.get('remove_path', 'local_path')
  25. transport.close()

SSH

  1. #Authon Ivor
  2. import paramiko
  3. #创建SSH实例
  4. ssh = paramiko.SSHClient()
  5. #设置不在known_host的主机
  6. ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  7. #建立连接
  8. ssh.connect(hostname="10.0.2.57",port=22,username="root:",password="test83@123")
  9. #执行命令,返回标准输入输出错误
  10. stdin, stdout, stderr = ssh.exec_command("df")
  11. #读取结果
  12. result = stdout.read()
  13. print(result.decode())
  14. #关闭连接
  15. ssh.close()
  16.  
  17. #Author:Ivor
  18. #######
  19. #funtion 1
  20. #######
  21. import paramiko
  22. private_key = paramiko.RSAKey.from_private_key_file('id_rsa')
  23.  
  24. ssh = paramiko.SSHClient()
  25.  
  26. ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  27.  
  28. ssh.connect(hostname='59.110.23.110', port=22, username='root', pkey=private_key)
  29.  
  30. stdin, stdout, stderr = ssh.exec_command('df')
  31.  
  32. result = stdout.read()
  33. print(result.decode())
  34. ssh.close()
  35.  
  36. ########
  37. #funtion 2
  38. ########
  39. import paramiko
  40. from io import StringIO
  41. key = '''XXX
  42. -----END RSA PRIVATE KEY-----'''
  43. private_key = paramiko.RSAKey(file_obj=StringIO(key))
  44. transport = paramiko.Transport((XXXX, 22))
  45. transport.connect(username='root', pkey=private_key)
  46.  
  47. ssh = paramiko.SSHClient()
  48. ssh._transport = transport
  49.  
  50. stdin, stdout, stderr = ssh.exec_command('df')
  51. result = stdout.read()
  52. transport.close()
  53. print(result)

Python学习-day9 线程的更多相关文章

  1. python学习笔记——线程threading (二)重写run()方法和守护进程daemon()

    1 run()方法 1.1 单个线程 在threading.Thread()类中有run()方法. from time import ctime,sleep import threading # 定义 ...

  2. python学习笔记——线程threading (一)

    1 线程threading 1.1 基本概述 也被称为轻量级的进程. 线程是计算机多任务编程的一种方式,可以使用计算机的多核资源. 线程死应用程序中工作的最小单元 1.2 线程特点 (1)进程的创建开 ...

  3. python学习day9

    目录 一.队列 二.生产者消费者模型 三.协程 四.select\poll\epoll 五.paramiko 六.mysql API调用 一.队列(queue) 队列分以下三种: class queu ...

  4. python学习Day9 内存管理

    复习 :文件处理 1. 操作文件的三步骤:-- 打开文件:此时该文件在硬盘的空间被操作系统持有 |  文件对象被应用程序持用 -- 操作文件:读写操作 -- 释放文件:释放操作系统对文件在硬盘间的持有 ...

  5. python 学习分享-线程

    多线程类似于同时执行多个不同程序,多线程运行有如下优点: 使用线程可以把占据长时间的程序中的任务放到后台去处理. 用户界面可以更加吸引人,这样比如用户点击了一个按钮去触发某些事件的处理,可以弹出一个进 ...

  6. Python学习之线程

    8.5 线程 进程:开辟空间,加载数据,资源单位 线程:流水线,执行代码,执行单位 8.5.1 线程的概念 是操作系统能够进行运算调度的最小单位,线程包含在进程中,是进程中的执行单元,一个进程至少包含 ...

  7. Python学习之==>线程&&进程

    一.什么是线程(thread) 线程是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一个线程指的是进程中一个单一顺序的控制流,一个进程中可以包含多个线程,每条线程并行 ...

  8. 4月28日 python学习总结 线程与协程

    一. 异步与回调机制 问题: 1.任务的返回值不能得到及时的处理,必须等到所有任务都运行完毕才能统一进行处理 2.解析的过程是串行执行的,如果解析一次需要花费2s,解析9次则需要花费18s 解决一: ...

  9. python学习day9 字符编码和文件处理

    1.字符编码 x='上' #unicode的二进制--------->编码-------->gbk格式的二进制 res=x.encode('gbk') #bytes 字节类型 print( ...

随机推荐

  1. ABAP数据转换规则

    数据转换规则: 可以将基本数据类型的源字段内容赋给其它基本数据类型的目标字段(除了数据类型 D 无法赋给数据类型 T,反之亦然).ABAP/4 也支持结构化数据和基本数据对象之间或结构不同的数据对象之 ...

  2. 【迷你微信】基于MINA、Hibernate、Spring、Protobuf的即时聊天系统:2.技术简介之MinaFilter(1)

    欢迎阅读我的开源项目<迷你微信>服务器与<迷你微信>客户端 Filter filter:过滤器?(不知道是不是这么翻译,算了知道意思就好了╮(╯▽╰)╭),这种东西在很多语言中 ...

  3. javaSe-hashMap

    package com.java.chap08.sec05; public class Student { private String name; private Integer age; publ ...

  4. JAVA多线程编程——JAVA内存模型

    一.何为“内存模型” 内存模型描述了程序中各个变量(实例域.静态域和数组元素)之间的关系,以及在实际计算机系统中将变量存储到内存和从内存中取出变量这样的底层细节,对象最终是存储在内存里面的,但是编译器 ...

  5. 关系代数演算So Easy

    关系代数运算So Easy 关系代数是以关系为运算的一组高级运算的集合.由于定义为属性个数 相同的元组的集合,因此集合代数的操作就可以引入到关系代数中.关系代数也可以看做是一种抽象的查询语言,是对关系 ...

  6. 一个.java文件内只能写一个class吗

    先给结论:当然不是!! 可以有多个类,但只能有一个public的类,并且public的类名必须与文件名相一致.一个文件中可以不含public类,如果只有一个非public类,此时可以跟文件名不同. 为 ...

  7. Memcached笔记之分布式算法

    1.根据余数进行分散:离散度高,但是增加或者移除服务器的时候,缓存充足的代价非常大.添加服务器后,余数就会产生巨变,这样就无法获取与保存时相同的服务器,从而音像缓存的命中率. 2.Consistent ...

  8. C-基础:形参char *&p与char *p

    char* &p:以引用传递的方式传指针char* p: 以值传递的方式传指针

  9. OO第三次电梯作业优化

    目录 第三次电梯作业个人优化 前言 优化思路 一.调度器 二.电梯 第三次电梯作业个人优化 前言 由于个人能力有限,第二次电梯作业只能完成正确性设计,没能进行优化,也因此损失了强测分数,于是第三次电梯 ...

  10. 转 WebService两种发布协议--SOAP和REST的区别

    转发文章 https://blog.csdn.net/zl834205311/article/details/62231545?ABstrategy=codes_snippets_optimize_v ...