python中的进程、线程、协程

线程和进程

(对于操作系统而言，一个任务就是一个线程)
线程是属于进程的(线程是进程的一个实体，是CPU调度和分派的基本单位，线程是比进程更小的能够独立运行的单位)，线程运行在进程空间内，同一进程所产生的线程共享同资源，当进程退出时该进程所产生的线程都会被强制退出并清除。线程可与属于同一进程的其它线程共享进程所拥有的全部资源，但是其本身基本上不拥有系统资源，只拥有一点在运行中必不可少的信息(如程序计数器、一组寄存器和栈)。

线程、进程与协程

线程和进程的操作是由程序触发系统接口，最后的执行者是操作系统；协程的操作则是程序员
协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保持状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。

协程的适用场景

当程序中存在大量不需要CPU的操作时（IO），适用于协程；

基本应用

1). 实现将一个列表中的每个数字加一操作

#导入线程模块
import threading
#定义一个列表
info=[1,2,3,44,555,888]

#功能函数
def func1(p,info,i):
    p+=1
    info[i]=p
    print('第%s个值完成加1'% (i+1), info)
#遍历列表
for i in range(len(info)):
	#调用线程
    th=threading.Thread(target=func1,args=(info[i],info,i))
    #启动线程
    th.start()

'''
执行结果：
第1个值完成加1 [2, 2, 3, 44, 555, 888]
第2个值完成加1 [2, 3, 3, 44, 555, 888]
第3个值完成加1 [2, 3, 4, 44, 555, 888]
第4个值完成加1 [2, 3, 4, 45, 555, 888]
第5个值完成加1 [2, 3, 4, 45, 556, 888]
第6个值完成加1 [2, 3, 4, 45, 556, 889]
'''

2).使用线程完成模仿红绿灯

#导入需要的模块
import threading
import time

#定义一个事件
event=threading.Event()
def light():
    count=0
    while True:
        if count<10:
            #设置Event对象内部的信号标志为True
            event.set()
            print("\033[42;1m--green light on---\033[0m",10-count)
        elif 10<=count<15:
            #清除Event对象内部的信号标志为False
            event.clear()                 #Clear()则用于清除标志位
            print("\033[43;1m--yellow light on---\033[0m",15-count)
        else:
            event.clear()
            print("\033[41;1m--red light on---\033[0m",25-count)
            if count>=25:
                count=0
        #停留时间1s
        time.sleep(1)
        count+=1

def car(name):
    while True:
        #Event对象is_set方法来判断内部的信号标志的状态(返回True/False)
        if event.is_set():
            print("%s is rinning..." % name)
            time.sleep(1)
        else:
            print("car is waiting")
            event.wait()      #等待对象event发生变化

#创建线程并启动线程
L=threading.Thread(target=light)
L.start()
M=threading.Thread(target=car,args=("RNG",))
M.start()

3).使用线程模仿银行存取钱操作

#导入模块
import threading

#  Lock类是threading中用于锁定当前线程的锁定类。其作用是对当前运行中的线程进行锁定，只有当前线程被释放后，后续线程才可以继续操作
lock=threading.Lock()

money=0
#存钱
def put_money(Sum):
    global money
    money+=Sum                   #x=Sum+money;money=x

#取钱
def get_money(Sum):
    global money
    money-=Sum

def run(Sum):
    for i in range(1000000):
        lock.acquire()
        put_money(Sum)
        get_money(Sum)
        lock.release()
'''
单线程不存在问题
但是在多线程中操作系统交叉处理赋值语句，
导致全局变量被一个线程修改，而另外的却不知情。
'''
t1=threading.Thread(target=run,args=(1000,))
t2=threading.Thread(target=run,args=(1000,))
t1.start()
t2.start()
t1.join()
t2.join()
print(money)

4)、进程的基本操作(基本操作与线程类似):

#导入进程模块
import multiprocessing
import time

#函数
def run(name):
    time.sleep(2)
    print("hello",name)

#程序入口
if __name__=="__main__":
	#创建进程
    p=multiprocessing.Process(target=run,args=("qq",))
    #启动进程
    p.start()
    #join方法，如果一个进程或者一个函数在执行过程中要调用另外一个进程，并且待到其完成以后才能接着执行，那么在调用这个进程时可以使用被调用线程的join方法。
    p.join()