#!/usr/bin/env python
# -*- coding:utf-8 -*- 
from multiprocessing import Process
import threading
import time
def foo(i):
    print 'say hi',i
for i in range(10):
    p = Process(target=foo,args=(i,))
    p.start()

#!/usr/bin/env python
#coding:utf-8
from multiprocessing import Process
from multiprocessing import Manager
import time
li = []
def foo(i):
    li.append(i)
    print 'say hi',li
for i in range(10):
    p = Process(target=foo,args=(i,))
    p.start()
print 'ending',li

#通過特殊的數據結構：數組（Array）
from multiprocessing import Process,Array
#創建一個只包含數字類型的數組（python中叫列表）
#并且數組是不可變的，在C，或其他語言中，數組是不可變的，之后再python中數組（列表）是可以變得
#當然其他語言中也提供可變的數組
#在C語言中數組和字符串是一樣的，如果定義一個列表，如果可以增加，那么我需要在你內存地址后面再開辟一塊空間，那我給你預留多少呢？
#在python中的list可能用鏈表來做的，我記錄了你前面和后面是誰。列表不是連續的，數組是連續的
'''
上面不是列表是“數組"數組是不可變的，附加內容是為了更好的理解數組！
'''
temp = Array('i', [11,22,33,44]) #這里的i是C語言中的數據結構，通過他來定義你要共享的內容的類型！點進去看~
def Foo(i):
    temp[i] = 100+i
    for item in temp:
        print i,'----->',item
for i in range(2):
    p = Process(target=Foo,args=(i,))
    p.start()
第二種方法：
#方法二：manage.dict()共享數據
from multiprocessing import Process,Manager  #這個特殊的數據類型Manager
manage = Manager()
dic = manage.dict() #這里調用的時候，使用字典，這個字典和咱們python使用方法是一樣的！
def Foo(i):
    dic[i] = 100+i
    print dic.values()
for i in range(2):
    p = Process(target=Foo,args=(i,))
    p.start()
    p.join()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from  multiprocessing import Process,Pool
import time
def Foo(i):
    time.sleep(2)
    return i+100
def Bar(arg):
    print arg
pool = Pool(5) #創建一個進程池
#print pool.apply(Foo,(1,))#去進程池里去申請一個進程去執行Foo方法
#print pool.apply_async(func =Foo, args=(1,)).get()
for i in range(10):
    pool.apply_async(func=Foo, args=(i,),callback=Bar)
print 'end'
pool.close()
pool.join()#進程池中進程執行完畢后再關閉，如果注釋，那么程序直接關閉。
'''
apply 主動的去執行
pool.apply_async(func=Foo, args=(i,),callback=Bar) 相當于異步，當申請一個線程之后，執行FOO方法就不管了，執行完之后就在執行callback ，當你執行完之后，在執行一個方法告訴我執行完了
callback 有個函數，這個函數就是操作的Foo函數的返回值！
'''

# Python程序說明線程的概念
# 導入線程模塊
import threading
def print_cube(num):
    """
    打印給定數字立方的函數
    """
    print("立方: {}".format(num * num * num))
def print_square(num):
    """
    打印給定數字平方的函數
    """
    print("平方: {}".format(num * num))
if __name__ == "__main__":
    # creating thread
    t1 = threading.Thread(target=print_square, args=(10,))
    t2 = threading.Thread(target=print_cube, args=(10,))
    # starting thread 1
    t1.start()
    # starting thread 2
    t2.start()
    # 等到線程 1 完全執行
    t1.join()
    # 等到線程 2 完全執行
    t2.join()
    # 兩個線程完全執行
    print("完成!")

import threading

t1 = threading.Thread(target=print_square, args=(10,)) 
t2 = threading.Thread(target=print_cube, args=(10,))

t1.start() 
t2.start()

t1.join() 
t2.join()

line = (yield)

# 用于演示協程執行的 Python3 程序
def print_name(prefix):
    print("Searching prefix:{}".format(prefix))
    while True:
        name = (yield)
        if prefix in name:
            print(name)
# 調用協程，什么都不會發生
corou = print_name("Dear")
# 這將開始執行協程并打印第一行 "Searching prefix..."
# 并將執行推進到第一個 yield 表達式
corou.__next__()
# 發送輸入
corou.send("Haiyong")
corou.send("Dear Haiyong")

# Python3 program for demonstrating
# closing a coroutine
def print_name(prefix):
    print("Searching prefix:{}".format(prefix))
    try :
        while True:
                name = (yield)
                if prefix in name:
                    print(name)
    except GeneratorExit:
            print("關閉協程！！")
corou = print_name("Dear")
corou.__next__()
corou.send("Haiyong")
corou.send("Dear Haiyong")
corou.close()

# 用于演示協程鏈接的 Python 程序

def producer(sentence, next_coroutine):
    '''
    producer 只是拆分字符串并將其
    提供給 pattern_filter 協程
    tokens = sentence.split(" ")
    for token in tokens:
        next_coroutine.send(token)
    next_coroutine.close()
def pattern_filter(pattern="ing", next_coroutine=None):
    在接收到的令牌中搜索模式，如果模式匹配，
    將其發送到 print_token() 協程進行打印
    print("Searching for {}".format(pattern))
    try:
        while True:
            token = (yield)
            if pattern in token:
                next_coroutine.send(token)
    except GeneratorExit:
        print("過濾完成！！")
def print_token():
    充當接收器，只需打印接收到的令牌
    print("我沉了，我會打印令牌")
            print(token)
        print("打印完成！")
pt = print_token()
pt.__next__()
pf = pattern_filter(next_coroutine = pt)
pf.__next__()
sentence = "Haiyong is running behind a fast moving car"
producer(sentence, pf)