day09-线程与进程

线程：是最小的执行单元，而进程由至少一个线程组成！在多道程序环境下，程序的执行属于并发执行，此时他们失去其封闭性，并具有间断性，UI及其运行结果不可再现性的特点，因此，决定了同学行的程序是不能参加并发执行的，否则就失去了意义！为了是程序可以并发执行，人们引入了进程！
进程是程序的一次执行
进程是一个程序及其数据在处理机上顺序执行时所发生的活动
进程是具有独立功能的程序在一个数据集合上运行的过程，他是系统进行资源分配和调度的一个独立单位
总而言之：进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位
线程：为了减少程序在迸发执行是付出的时空开销，使os具有更好的并发性

1、multiprocessing:提供跨平台的多进程支持

　　　　Python中有multiprocessing模块提供跨平台的多进程支持：

from multiprocessing import Process
import os

# 子进程要执行的代码
def run_proc(name):
    print 'Run child process %s (%s)...' % (name, os.getpid())

if __name__=='__main__':
    print 'Parent process %s.' % os.getpid()
    p = Process(target=run_proc, args=('test',))
    print 'Process will start.'
    p.start()　　　　#启动进程
    p.join()　　　　 #等待子进程结束后再继续往下运行，通常用于进程间的同步。一个过后执行下一个
    print 'Process end.'

多线程：（启动多个线程，列表存储，计算总时间）

import threading
import time
def run(n):
    print("task ",n )
    time.sleep(2)
    print("task done",n)
start_time = time.time()
t_objs = [] #存线程实例
for i in range(5):
    t = threading.Thread(target=run,args=("t-%s" %i ,))
    t.start()
    t_objs.append(t) #为了不阻塞后面线程的启动，不在这里join，先放到一个列表里
for t in t_objs: #循环线程实例列表，等待所有线程执行完毕
    t.join()
print("----------all threads has finished...")
print("cost:",time.time() - start_time)
# task  t-0
# task  t-1
# task  t-2
# task  t-3
# task  t-4
# task done t-0
# task done t-1
# task done t-2
# task done t-3
# task done t-4
# ----------all threads has finished...
# cost: 2.0021145343780518

守护线程：

import threading
import time
def run(n):
    print("task ",n )
    time.sleep(2)
    print("task done",n,threading.current_thread())#打印当前线程
start_time = time.time()
t_objs = [] #存线程实例
for i in range(5):
    t = threading.Thread(target=run,args=("t-%s" %i ,))
    t.setDaemon(True) #把当前线程设置为守护线程，主线程消失守护线程强制退出，不用等join中所有线程结束！经常用于打开文件，监听端口
    t.start()
    t_objs.append(t) #为了不阻塞后面线程的启动，不在这里join，先放到一个列表里
for t in t_objs: #循环线程实例列表，等待所有线程执行完毕
    t.join()
time.sleep(2)
print("----------all threads has finished...",threading.current_thread(),threading.active_count())
print("cost:",time.time() - start_time)

线程锁：解决不同线程同时修改数据！

import threading
import time
def run(n):
    lock.acquire()#锁
    global  num
    num +=1
    time.sleep(1)
    lock.release()
lock = threading.Lock()#开锁
num = 0
t_objs = [] #存线程实例
for i in range(5):
    t = threading.Thread(target=run,args=("t-%s" %i ,))
    t.start()
    t_objs.append(t) #为了不阻塞后面线程的启动，不在这里join，先放到一个列表里

for t in t_objs: #循环线程实例列表，等待所有线程执行完毕
    t.join()

print("----------all threads has finished...",threading.current_thread(),threading.active_count())

print("num:",num)
# ----------all threads has finished... <_MainThread(MainThread, started 6872)> 1
# num: 5

线程Event案例--红绿灯（不同线程之间同步执行控制，红-》停）

import time
import threading
event = threading.Event()
def lighter():
    count = 0
    event.set() #先设置绿灯
    while True:
        if count >5 and count < 10: #改成红灯
            event.clear() #把标志位清了
            print("\033[41;1mred light is on....\033[0m")
        elif count >10:
            event.set() #变绿灯
            count = 0
        else:
            print("\033[42;1mgreen light is on....\033[0m")
        time.sleep(1)
        count +=1

def car(name):
    while True:
        if event.is_set(): #代表绿灯
            print("[%s] running..."% name )
            time.sleep(1)
        else:
            print("[%s] sees red light , waiting...." %name)
            event.wait()
            print("\033[34;1m[%s] green light is on, start going...\033[0m" %name)

light = threading.Thread(target=lighter,)
light.start()
car1 = threading.Thread(target=car,args=("Tesla",))
car1.start()
# [Tesla] running...
# [Tesla] running...
# green light is on....
# green light is on....
# [Tesla] running...
# green light is on....
# [Tesla] running...