python之路--线程和进程

线程

python中有关线程的有两个模块比较常用
分别是thread和threading。
首先说为什么要用线程呢。正如那句话吃着火锅听着歌。
像之前写的python程序，程序执行，每时刻只有一个任务，只能一个任务执行完再执行下一个。
像有时候需要执行相同的某个操作，比如说ping某些主机，检测是否存活。如果一个个检测，写循环，一个ping完再ping另一个。那么耗时耗力。所以最好的方法是能同时ping多个地址。但是不可能同时启动多个脚本去执行。所以这时候就需要考虑多线程。

import os,threading
host_list = []
def ping_host(host_ip):
    #....
    #ping host然后返回是否ping通。

for i in host_list:
    t = threading.Thread(target=ping_host, args=(i,))
    t.start()

•start 线程准备就绪，等待CPU调度
•setName 为线程设置名称
•getName 获取线程名称
•setDaemon 设置为后台线程或前台线程（默认）
如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止
如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
•join 逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
•run 线程被cpu调度后执行Thread类对象的run方法

线程锁

在使用多线程的时候会遇到一个问题。因为有的线程是同时运行的，如果同时操作同一个数据的话，那么就会有问题，所以这时候要保证一个线程在操作数据的时候，其他线程不会操作这个数据。那么就要用到线程锁。
线程锁可以保证一个线程在操作的时候，其他线程不会访问到该数据。

import threading
import time

num = 0

# 定义一个锁，这里写的是RLock,还有一种锁是Lock。

> 这两种琐的主要区别是：RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。注意：如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的锁。

lock = threading.RLock()
# 定义一个函数对num进行加1操作。
def Add_num():
    # 锁定
    lock.acquire()
    global num
    num +=1
    time.sleep(1)
    print num
    # 释放
    lock.release()

for i in range(10):
    t = threading.Thread(target=Add_num)
    t.start()

事件

threading.Event机制类似于一个线程向其它多个线程发号施令的模式，其它线程都会持有一个threading.Event的对象，这些线程都会等待这个事件的“发生”，如果此事件一直不发生，那么这些线程将会阻塞，直至事件的“发生”。有三个主要的方法set、wait、clear。
http://www.360doc.com/content/13/1105/23/12892305_327019058.shtml

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
def do(event):
    print 'start'
    event.wait()
    print 'execute'
event_obj = threading.Event()
for i in range(10):
    t = threading.Thread(target=do, args=(event_obj,))
    t.start()
event_obj.clear()
inp = raw_input('input:')
if inp == 'true':
    event_obj.set()

进程

python中使用进程的模块是multiprocessing

import multiprocessing
import time
def ass(args):
    n = 5
    while n > 0:
        print("The time is {0}".format(time.ctime()))
        time.sleep(args)
        n -= 1
if __name__ == "__main__":
    # 创建一个进程
    p = multiprocessing.Process(target = ass, args = (3,))
    p.start()
    # 打印进程的相关信息。
    print "p.pid:", p.pid
    print "p.name:", p.name
    print "p.is_alive:", p.is_alive()

协程

说起协程要引用一个著名的例子。生产者消费者模型。
协程，与线程的抢占式调度不同，它是协作式调度，大致上就是一种可控制的回调，是比线程更轻量级的一种实现异步编程的方式。协程在Python中可以用generator(生成器)实现，生成器主要由yeild关键字实现生成器是一个可迭代的对象，每次调用next方法就返回一个值。
而用yeild实现协程的话，其实有挺多不同的方式，不过大致的思想都是用yeild来暂停当前执行的程序，转而执行另一个，再在恰当的时候（可以控制）回来执行。用法很灵活。

#coding=utf-8
import time
import sys
# 生产者
def produce(l):
    i=0
    while 1:
        if i < 5:
            l.append(i)
            yield i
            i=i+1
            time.sleep(1)
        else:
            return

# 消费者
def consume(l):
    p = produce(l)
    while 1:
        try:
            p.next()
            while len(l) > 0:
                print l.pop()
        except StopIteration:
            sys.exit(0)
l = []
consume(l)