Python进阶（2）_进程与线程的概念

1 进程与线程相关概念

1.1 进程

进程定义：

　　进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成，是最小的资源管理单元

　　程序：用来描述进程要完成哪些功能以及如何完成；

　　数据集：则是程序在执行过程中所需要使用的资源；

　　进程控制块：用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。

1.2 线程

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

　　线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。线程没有自己的系统资源。

1.3 进程与线程的关系

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

进程和线程的关系：

　　(1)一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
　　(2)资源分配给进程，同一进程的所有线程共享该进程的所有资源。
　　(3)CPU分给线程，即真正在CPU上运行的是线程。

1.4 并行和并发

切换：切换的操作者是操作系统

进程/线程切换的原则：

　　1、时间片

　　2、遇到IO操作切换

　　3、优先级切换

并行处理（Parallel Processing）

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

并发处理(concurrency Processing)：

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

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

　　在python中给每个进程添加一把锁，使每个进程只有一个线程被执行，即在python中的进程中没有线程的并行

1.5 同步与异步

　　在计算机领域，同步就是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去；

　　异步是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样可以提高执行的效率。

　　举个例子，打电话时就是同步通信，发短息时就是异步通信。

2.threading模块

2.1用Thread类创建子线程

import threading,time
def foo(n):
    print('>>>>>>>>>>>%s'%n)
    time.sleep(n)
def bar(n):
    print('>>>>>>>>>>>%s' % n)
    time.sleep(n)
s=time.time()
t1=threading.Thread(target=foo,args=(2,))
t1.start()
t2=threading.Thread(target=bar,args=(5,))
t2.start()

print('ending！')

　　

2.2 Thread类继承式创建

#继承Thread式创建

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)

t1=MyThread(56)
t2=MyThread(78)

t1.start()
t2.start()
print("ending")

　　

2.3 Thread类的实例方法

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

 # setDaemon(True)：
         '''
          将线程声明为守护线程，必须在start() 方法调用之前设置，如果不设置为守护线程程序会被无限挂起。 当我们在程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程 就分兵两路，分别运行，那么当主线程完成
          想退出时，会检验子线程是否完成。如果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是只要主线程
          完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以 用setDaemon方法啦''

 Thread实例对象的方法
   # isAlive(): 返回线程是否活动的。
   # getName(): 返回线程名。
   # setName(): 设置线程名。

 threading模块提供的一些方法：
   # threading.currentThread(): 返回当前的线程变量。
   # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
   # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。'

举例：

import threading,time

def foo(n):
    print('>>>>>>>>>>>%s'%n)
    time.sleep(n)
    print(threading.active_count())

def bar(n):
    print('>>>>>>>>>>>%s' % n)
    time.sleep(n)
    print(threading.active_count())

s=time.time()
t1=threading.Thread(target=foo,args=(2,))
# t1.setDaemon(True)
t1.start()

t2=threading.Thread(target=bar,args=(5,))
# t2.setDaemon(True)
t2.start()

t1.join()
t2.join()

print('++++++++++',threading.active_count())
print('ending！')
print('cost time:',time.time()-s)