Python进程、线程、协程

进程和线程的解释

1.   进程（process）和线程（thread）是操作系统的基本概念,计算机的核心是CPU，它承担了所有的计算任务；
2.   单个CPU一次只能运行一个任务,代表单个CPU总是运行一个进程，其他进程处于非运行状态；
3.   一个进程有且最少包括一个线程；
4.   一个进程内存空间是共享的，每个线程可以使用这个共享内存；一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存；
5.   防止其它进程占用某一块内存区域使用互斥锁（Mutual exclusion，缩写 Mutex）；
6.   保证多个线程不会互相冲突使用“信号量”（Semaphore）;mutex是semaphore的一种特殊情况（n=1时）。也就是说，完全可以用后者替代前者。但是，因为mutex较为简单，且效率高，所以在必须保证资源独占的情况下，还是采用这种设计。

  操作系统的设计，因此可以归结为三点：

（1）以多进程形式，允许多个任务同时运行；

（2）以多线程形式，允许单个任务分成不同的部分运行；

（3）提供协调机制，一方面防止进程之间和线程之间产生冲突，另一方面允许进程之间和线程之间共享资源。

进程解释

• 狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。

• 广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。

  进程的概念主要有两点：

•   第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。
• 第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。

     进程是操作系统中最基本、重要的概念。是多道程序系统出现后，为了刻画系统内部出现的动态情况，描述系统内部各道程序的活动规律引进的一个概念,所有多道程序设计操作系统都建立在进程的基础上。

线程解释

     线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。

进程和线程的区别？

  进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

1) 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

2) 线程的划分尺度小于进程，使得多线程程序的并发性高。

3) 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

4) 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

5) 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

 线程和进程的优缺点

   线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。

Python GIL(Global Interpreter Lock)　　

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

上面的核心意思就是，无论你启多少个线程，你有多少个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。

Python threading模块

线程有2种调用方式

1. 简单的调用方式
2. 自定义类的调用方式

简单调用方式:自定义一个继承threading.Thread的子类,通过自定义类的对象调用

import threading
import time
def f1(n):
    print("time time time ...",n)
    time.sleep(5)

t = threading.Thread(target=f1,args=(123,))
t1 = threading.Thread(target=f1,args=(456,))
t.start()
t1.start()

2.自定义类的调用方式

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__':
    for i in range(20):
        t1 = Mythread(i)
        t1.start()

Join & Daemon

 

def run(n):
    print("[%s]-------running-----
" % n)
    time.sleep(2)
    print('----done----')

def main():
    for i in range(5):
        t = threading.Thread(target=run,args=[i,])
        t.start()
        t.join(1)
        print('start thread', t.getName())


m = threading.Thread(target=main,args=[])
m.setDaemon(True)
m.start()
m.join(timeout=2)
print("-----main thread done----")

更多的方法：

• start 不代表当前线程并不会立即被执行，而是等待CPU调度,(准备就绪,等待调度)
• setName 为线程设置名称
• setDaemon(True) True表示主线程不等待子线程,执行完自己的任务后，自动关闭，子线程有可能未执行完毕。（默认情况下，主线程要等待子线程执行完毕后再关闭主线程）,(True:后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止;False:前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止)
• join(2) 如果不想让线程并发的操作，表示主线程到此等待，等待直到子线程执行完毕。如果加上参数，表示主线程在此最多等几秒。该方法使得多线程变得无意义
• run 线程被cpu调度后自动执行线程对象的run方法

线程锁(互斥锁Mutex)

def addNum():
    global num #在每个线程中都获取这个全局变量
    print('--get num:',num )
    time.sleep(1)
    lock.acquire() #修改数据前加锁
    num  -=1 #对此公共变量进行-1操作
    lock.release() #修改后释放

num = 100  #设定一个共享变量
thread_list = []
lock = threading.Lock() #生成全局锁
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 )

RLock（递归锁）

说白了就是在一个大锁中还要再包含子锁

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

import threading,time   def run1():     print("grab the first part data")     lock.acquire()     global num     num +=1     lock.release()     return num def run2():     print("grab the second part data")     lock.acquire()     global  num2     num2+=1     lock.release()     return num2 def run3():     lock.acquire()     res = run1()     print('--------between run1 and run2-----')     res2 = run2()     lock.release()     print(res,res2)     if __name__ == '__main__':       num,num2 = 0,0     lock = threading.RLock()     for i in range(10):         t = threading.Thread(target=run3)         t.start()   while threading.active_count() != 1:     print(threading.active_count()) else:     print('----all threads done---')     print(num,num2)

　　

Semaphore(信号量)

互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

import threading,time   def run(n):     semaphore.acquire()     time.sleep(1)     print("run the thread: %s " %n)     semaphore.release()   if __name__ == '__main__':       num= 0     semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行     for i in range(20):         t = threading.Thread(target=run,args=(i,))         t.start()   while threading.active_count() != 1:     pass #print threading.active_count() else:     print('----all threads done---')     print(num)