进程线程，基础

Posted 2020-09-28

Python之 进程和线程

---

一、

进程的定义：

　　进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成我们编写的程序用来描述进程要完成那些功能以及如何完成；数据集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以用它来控制和管理进程，踏它是系统用来感知进程存在的唯一标志。

线程：

　　线程的出现时为了降低上下文切换的消耗，提高系统的并发性，并突破一个进程只能干一件事的缺陷，使进程内并发成为可能。

进程与线程的关系：

　　进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础，或者说进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。

　　线程则是进程的一个实例，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。

　　

强调：

• 一个线程只能属于一个进程，而一个进程可以有多个线程，至少有一个线程；
• 资源分配给进程，同一进程的所有线程共享改进程的所有资源；
• CPU分给线程，即真正在CPU上运行的是线程；

零碎：

线程：最小的执行单元

进程：最小的资源管理单元

进程/线程切换的操作者是：操作系统

切换的原则是：

• 时间片（时钟周期）
• 遇到I/O操作切换
• 按优先级切换

对于python来说：

进程和线程处理的任务分为两种：
I/O密集型任务：程序存在大量的I/O操作

计算密集型任务：程序存在大量计算操作

python在处理多线程处理时：

I/O密集型任务具有优势

但不推荐使用计算密集型任务，这种缺陷可以用多进程来解决，但多线程解决不了

并行和并发：

并行处理（Parallel Processing）是计算机系统中能同时执行两个或更多处理的一种计算方法，并行处理可以同时工作于同一程序的不同方面。并行处理的主要目的是节省大型和复杂问题的解决时间；

并发处理（Concurrency Processing）：指一个时间段中有几个程序都处于已启动到运行完毕之间，且这几个程序都是同一个处理机（CPU）上运行，但任一个时刻点上只有一个程序在处理机（CPU）上运行

强调：

并发的关键是你有处理多个任务的能力，不一定要同时。并行的关键是你有同时吹多个任务的能力，所以说，并行是并发的子集

 

 

同步与异步：

在计算机领域，同步就是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程就会一直等待下去，直到收到返回信息才继续执行下去，异步是值进程不需要一直等下去，而继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样可以提高执的效率。举个例子，打电话时就是同步通信，发短息时就是异步通信。

 二、threading模块

举例说明：

import threading
import time
def foo(n):
    time.sleep(n)
    print(‘run the foo function ‘,n)
    # print(threading.activeCount()) #查看线程数
def bar(n):
    # print(‘run the bar function ‘,n)
    time.sleep(n)
    print(‘run the bar function ‘,n)
s=time.time()
t1=threading.Thread(target=foo,args=(2,))
# t1.setDaemon(True) #守护线程
t2=threading.Thread(target=bar,args=(5,)) #生成实例
# t2.setDaemon(True) #守护线程
t1.start()
t2.start() #启动实例
print(‘线程数为：‘,threading.activeCount())
t1.join() #在子进程执行完毕之前，阻塞父进程
t2.join()
print(‘ending!‘)
print(‘cost time:‘,time.time() - s)
‘‘‘
t2.join():在子线程完成运行之前，这个子线程的父线程将一直被阻塞。
在这个程序中，如果声明了守护进程，但是t1.join()没有注释掉，也是要等t2运行完整个程序才能结束
守护进程：如果声明为守护进程，那么，它将和父进程一起退出，如果不声明，那么，此进程将在执行完毕才能退出
‘‘‘

 

 

 

 join()和setDaemon()

# join()：在子线程完成运行之前，这个子线程的父线程将一直被阻塞。

# setDaemon(True)：
        ‘‘‘
         将线程声明为守护线程，必须在start() 方法调用之前设置，如果不设置为守护线程程序会被无限挂起。

         当我们在程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程 就分兵两路，分别运行，那么当主线程完成

         想退出时，会检验子线程是否完成。如果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是只要主线程

         完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以 用setDaemon方法啦‘‘‘


import threading
from time import ctime,sleep
import time

def Music(name):

        print ("Begin listening to {name}. {time}".format(name=name,time=ctime()))
        sleep(3)
        print("end listening {time}".format(time=ctime()))

def Blog(title):

        print ("Begin recording the {title}. {time}".format(title=title,time=ctime()))
        sleep(5)
        print(‘end recording {time}‘.format(time=ctime()))


threads = []


t1 = threading.Thread(target=Music,args=(‘FILL ME‘,))
t2 = threading.Thread(target=Blog,args=(‘‘,))

threads.append(t1)
threads.append(t2)

if __name__ == ‘__main__‘:

    #t2.setDaemon(True)

    for t in threads:

        #t.setDaemon(True) #注意:一定在start之前设置
        t.start()

        #t.join()

    #t1.join()
    #t2.join()    #  考虑这三种join位置下的结果？

    print ("all over %s" %ctime())

 

 

 三、GIL（全局解释器锁）