进程和线程
进程
进程就是一个程序在一个数据集上的一次动态执行过程.
进程一般由程序, 数据集, 进程控制块三部分组成.
我们编写的程序用来描述进程要完成哪些功能以及如何完成;
数据集则是程序在执行过程中所需要使用的资源;
进程控制块用来记录进程的外部特征, 描述进程的执行变化过程, 系统可以利用它来控制和管理进程, 它是系
统感知进程存在的唯一标志.
举一例说明进程: 想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕. 他有做生日蛋糕的食谱, 厨房里有所需 的原料: 面粉, 鸡蛋, 糖, 香草汁等. 在这个比喻中, 做蛋糕的食谱就是程序 (即用适当形式描述的算法) 计算机科学家就是处理器 (CPU), 而做蛋糕的各种原料就是输入数据. 进程就是厨师阅读食谱, 取来各种原料以及烘制蛋糕等一系列动作的总和. 现在假设计算机科学家的儿子哭着跑了进来, 说他的头被一只蜜蜂蛰了. 计算机科学家就记录下他 照着食谱做到哪儿了(保存进程的当前状态), 然后拿出一本急救手册, 按照其中的指示处理蛰伤. 这 里, 我们看到处理机从一个进程(做蛋糕) 切换到另一个高优先级的进程(实施医疗救治), 每个进程 拥有各自的程序(食谱和急救手册). 当蜜蜂蛰伤处理完之后, 这位计算机科学家又回来做蛋糕, 从他 离开时的那一步继续做下去.
线程
线程的出现是为了降低上下文切换的消耗, 提高系统的并发性, 并突破一个进程只能干一样事的缺陷, 使到进程内并发成为可能. 假设, 一个文本程序, 需要接受键盘输入, 将内容显示在屏幕上, 还需要保存信息到硬盘中. 若只有 一个进程, 势必造成同一时间只能干一样事的尴尬(当保存时, 就不能通过键盘输入内容). 若有多 个进程, 每个进程负责一个任务, 进程 A 负责接收键盘输入的任务, 进程 B 负责将内容显示在屏幕上的 任务, 进程 C 负责保存内容到硬盘中的任务. 这里进程 A,B,C 间的协作涉及到了进程通信问题, 而且 有共同都需要拥有的东西 ------- 文本内容, 不停的切换造成性能上的损失. 若有一种机制, 可以使 任务 A,B,C 共享资源, 这样上下文切换所需要保存和恢复的内容就少了, 同时又可以减少通信所带 来的性能损耗, 那就好了. 是的, 这种机制就是线程. 线程也叫轻量级进程, 它是一个基本的 CPU 执行单元, 也是程序执行过程中的最小单元, 由线程 ID, 程序 计数器, 寄存器集合和堆栈共同组成. 线程的引入减小了程序并发执行时的开销, 提高了操作系统的并发 性能. 线程没有自己的系统资源.
二者区别
一个程序至少有一个进程, 一个进程至少有一个线程.(进程可以理解成线程的容器)
进程在执行过程中拥有独立的内存单元, 而多个线程共享内存, 从而极大地提高了程序的运行效率.
线程在执行过程中与进程还是有区别的. 每个独立的线程有一个程序运行的入口, 顺序执行序列和程序的出口. 但是线程不能够独立执行, 必须依存在应用程序中, 由应用程序提供多个线程执行控制.
进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动, 进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体, 是 CPU 调度和分派的基本单位, 它是比进程更小的能独立运行的基本单位. 线程自己基本上不拥有系统资源, 只拥有一点在运行中必不可少的资源 (如程序计数器, 一组寄存器和栈) 但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
一个线程可以创建和撤销另一个线程; 同一个进程中的多个线程之间可以并发执行.
python 的线程与 threading 模块
1. 线程的两种调用方式
threading 模块建立在 thread 模块之上. thread 模块以低级, 原始的方式来处理和控制线程, 而 threading 模块通过对 thread 进行二次封装, 提供了更方便的 API 来处理线程.
- import threading
- import time
- def sayhi(num): #定义每个线程要运行的函数
- print("running on number:%s" %num)
- time.sleep(3)
- if __name__ == '__main__':
- t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例
- t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例
- t1.start() #启动线程
- t2.start() #启动另一个线程
- print(t1.getName()) #获取线程名
- print(t2.getName())
- View Code
2. 继承式调用
- import threading
- import time
- class MyThread(threading.Thread):
- def __init__(self,num):
- threading.Thread.__init__(self)
- self.num = num
- def run(self):# 定义每个线程要运行的函数
- print("running on number:%s" %self.num)
- time.sleep(3)
- if __name__ == '__main__':
- t1 = MyThread(1)
- t2 = MyThread(2)
- t1.start()
- t2.start()
- print("ending......")
- View Code
3.threading.thread 的实例方法
- import threading
- from time import ctime,sleep
- import time
- def ListenMusic(name):
- print ("Begin listening to %s. %s" %(name,ctime()))
- sleep(3)
- print("end listening %s"%ctime())
- def RecordBlog(title):
- print ("Begin recording the %s! %s" %(title,ctime()))
- sleep(5)
- print('end recording %s'%ctime())
- threads = []
- t1 = threading.Thread(target=ListenMusic,args=('水手',))
- t2 = threading.Thread(target=RecordBlog,args=('python 线程',))
- threads.append(t1)
- threads.append(t2)
- if __name__ == '__main__':
- for t in threads:
- #t.setDaemon(True) #注意: 一定在 start 之前设置
- t.start()
- # t.join()
- # t1.join()
- t1.setDaemon(True)
- print ("all over %s" %ctime())
- View Code
join(): 在子线程完成运行之前, 这个子线程的父线程将一直被阻塞.
setDaemon(True):
将线程声明为守护线程, 必须在 start() 方法调用之前设置, 如果不设置为守护线程程序会被无限挂起. 这个方法基本和 join 是相反的.
在程序运行中, 执行一个主线程, 如果主线程又创建一个子线程, 主线程和子线程 就分兵两路, 分别运行, 那么当主线程完成想退出时,
会检验子线程是否完成. 如 果子线程未完成, 则主线程会等待子线程完成后再退出. 但是有时候我们需要的是 只要主线程完成了,
不管子线程是否完成, 都要和主线程一起退出, 这时就可以 用 setDaemon 方法啦
- # run(): 线程被 CPU 调度后自动执行线程对象的 run 方法
- # start(): 启动线程活动.
- # isAlive(): 返回线程是否活动的.
- # getName(): 返回线程名.
- # setName(): 设置线程名.
threading 模块提供的一些方法:
- # threading.currentThread(): 返回当前的线程变量.
- # threading.enumerate(): 返回一个包含正在运行的线程的 list. 正在运行指线程启动后, 结束前, 不包括启动前和终止后的线程.
- # threading.activeCount(): 返回正在运行的线程数量, 与 len(threading.enumerate())有相同的结果.
- View Code
4. 同步锁(Lock)
- import time
- import threading
- def addNum():
- global num #在每个线程中都获取这个全局变量
- #num-=1
- temp=num
- #print('--get num:',num )
- time.sleep(0.1)
- num =temp-1 #对此公共变量进行 - 1 操作
- num = 100 #设定一个共享变量
- thread_list = []
- for i in range(100):
- t = threading.Thread(target=addNum)
- t.start()
- thread_list.append(t)
- for t in thread_list: #等待所有线程执行完毕
- t.join()
- print('final num:', num )
- View Code
思考:
多个线程都在同时操作同一个共享资源, 所以造成了资源破坏, 怎么办呢?(join 会造成串行, 失去所线程的意义)
我们可以通过同步锁来解决这种问题
- R=threading.Lock()
- ####
- def sub():
- global num
- R.acquire()
- temp=num-1
- time.sleep(0.1)
- num=temp
- R.release()
- View Code
来源: http://www.bubuko.com/infodetail-2984875.html