import os

# 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以

pid = os.fork()

    if pid == 0:
        print('哈哈1')

    else:
      print('哈哈2')

# 程序执行到os.fork()时，操作系统会创建一个新的进程（子进程），然后复制父进程的所有信息到子进程中
# 然后父进程和子进程都会从fork()函数中得到一个返回值，在子进程中这个值一定是0，而父进程中是子进程的 id号
# 普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回
# getpid()是获取当前进程（主进程或子进程）的id、getppid()获取父进程的id

os.fork()
os.fork()
os.fork()      # 就变成了8个进程

from multiprocessing import Process
import time

def test():
    while True:
        print("---test---")
        time.sleep(1)
        
P = Process(target=test)

P.start()  # 让这个进程开始执行test函数里的代码

while True:
    print("---main---")
    time.sleep(1)

说明：
# 创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动
# 这样创建进程比fork()还要简单
# join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步，这就与fork不同，需要等子进程结束，主进程才可以结束

Process([group [, target [, name [,  args [, kwargs]]]]])

P0 = Pool(3) # 定义一个进程池，最大进程数3 
for i in range(0,10):

    # Pool.apply_async(要调用的目标,(传递给目标的参数元组,))（非堵塞式）
    # Pool.apply(worker,(i,)) （堵塞式），主进程卡在这里，需要等子进程完成才能添加
    # 每次循环将会用空闲出来的子进程去调用目标
    
    P0.apply_async(worker,(i,)) # work是一个函数
    P0.close() # 关闭进程池，关闭后po不再接收新的请求
    P0.join() # 等待po中所有子进程执行完成，必须放在close语句之后

p = process(target=xxx)
p.start()
# 子进程和父进程都可执行

pool = Pool(3)
pool.apply_async(xxx)
# 主进程一般用来等待，真正的任务都在子进程中执行

from multiprocessing import Queue

q = Queue(3) # 初始化一个Queue对象，最多可接收三条put消息

try:
    q.put_nowait("消息4")

except:
    print("消息列队已满，现有消息数量:%s"%q.qsize())

import threading
import time

def saySorry():

    print("Python才是最好的语言")

    time.sleep(1)

if __name__ == "__main__":

    for i in range(5):

    t = threading.Thread(target=saySorry)

    t.start() # 启动线程，即让线程开始执行

说明：
# 可以明显看出使用了多线程并发的操作，花费时间要短很多
# 创建好的线程，需要调用start()方法来启动
# 主线程会等待所有的子线程结束后才结束

# 创建锁
mutex = threading.Lock()

# 锁定
mutex.acquire([blocking])
 
# 释放
mutex.release()

# 程序设计时要尽量避免（银行家算法）
# 添加超时时间等
if mutex.acquire(2):

pool.apply_async(func=test,callback=test2) # callback是回调

import os

rpid = os.fork()

if rpid<0:
    print("fork调用失败")
    
elif rpid == 0:
    print("我是子进程（%s），我的父进程是（%s）"%(os.getpid(),os.getppid()))
    x+=1
    
else:
    print("我是父进程（%s），我的子进程是（%s）"%(os.getpid(),rpid))
print("父子进程都可以执行这里的代码")

import os
import time

num = 0
# 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以
pid = os.fork()

if pid == 0:
    num+=1
    print('哈哈1---num=%d'%num)
    
else:
    time.sleep(1)
    num+=1
    print('哈哈2---num=%d'%num)

from multiprocessing import Process
import time
import os

# 继承Process类
class Process_Class(Process):

    # 因为Process类本身也有__init__方法，这个子类相当于重写了这个方法，
    # 但这样就会带来一个问题，我们并没有完全的初始化一个Process类，所以就不能使用从这个类继承的一些方法和属性，
    # 最好的方法就是将继承类本身传递给Process.__init__方法，完成这些初始化操作
    def __init__(self,interval):

         Process.__init__(self)
         self.interval = interval 

    # 重写了Process类的run()方法
    def run(self):

        print("子进程(%s) 开始执行，父进程为（%s）"%(os.getpid(),os.getppid()))

        t_start = time.time()
        time.sleep(self.interval)
        t_stop = time.time()
        print("(%s)执行结束，耗时%0.2f秒"%(os.getpid(),t_stop-t_start))

 if __name__=="__main__":

    t_start = time.time()
    print("当前程序进程(%s)"%os.getpid())        
    p1 = Process_Class(2)
    # 对一个不包含target属性的Process类执行start()方法，就会运行这个类中的run()方法，所以这里会执行p1.run()
    p1.start()
    p1.join()
    t_stop = time.time()
    print("(%s)执行结束，耗时%0.2f"%(os.getpid(),t_stop-t_start))

from multiprocessing import Pool
import os,time,random

def worker(msg):

    t_start = time.time()

    print("%s开始执行,进程号为%d"%(msg,os.getpid()))
    # random.random()随机生成0~1之间的浮点数
    time.sleep(random.random()*2) 
    
    t_stop = time.time()

    print(msg,"执行完毕，耗时%0.2f"%(t_stop-t_start))

       
po=Pool(3) # 定义一个进程池，最大进程数3

for i in range(0,10):

    # Pool.apply_async(要调用的目标,(传递给目标的参数元祖,))
    # 每次循环将会用空闲出来的子进程去调用目标

    po.apply_async(worker,(i,))

print("----start----")
po.close() # 关闭进程池，关闭后po不再接收新的请求

po.join() # 等待po中所有子进程执行完成，必须放在close语句之后

print("-----end-----")

from multiprocessing import Process, Queue
import os, time, random

# 写数据进程执行的代码:
def write(q):

    for value in ['A', 'B', 'C']:
        print 'Put %s to queue...' % value
                q.put(value)

        time.sleep(random.random())

# 读数据进程执行的代码:
def read(q):

    while True:
        if not q.empty():
            value = q.get(True)
            print 'Get %s from queue.' % value
            time.sleep(random.random())

        else:
            break

if __name__=='__main__':

    # 父进程创建Queue，并传给各个子进程：
    q = Queue()

    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))

    # 启动子进程pw，写入:
    pw.start()    
    # 等待pw结束:
    pw.join()

    # 启动子进程pr，读取:
    pr.start()
    pr.join()

    # pr进程里是死循环，无法等待其结束，只能强行终止:

    print '' "
    print '所有数据都写入并且读完'

import threading
from time import sleep,ctime

def sing():

    for i in range(3):

        print("正在唱歌...%d"%i) 

        sleep(1)

def dance():

    for i in range(3):

        print("正在跳舞...%d"%i)

        sleep(1)

if __name__ == '__main__':

    print('---开始---:%s'%ctime())

    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)

    t1.start()
    t2.start()

    # sleep(5) # 屏蔽此行代码，试试看，程序是否会立马结束？

    print('---结束---:%s'%ctime())

from threading import Thread
import time

g_num = 100

def work1():

    global g_num
    
    for i in range(3):
        g_num += 1
        print("----in work1, g_num is %d---"%g_num)

def work2():
    global g_num
    print("----in work2, g_num is %d---"%g_num)


print("---线程创建之前g_num is %d---"%g_num)

t1 = Thread(target=work1)
t1.start()

# 延时一会，保证t1线程中的事情做完

time.sleep(1)

t2 = Thread(target=work2)
t2.start()

import threading
import time

class MyThread1(threading.Thread):

    def run(self):

        if mutexA.acquire():
            print(self.name+'----do1---up----')
            time.sleep(1)

        if mutexB.acquire():
            print(self.name+'----do1---down----')
            mutexB.release()

        mutexA.release()


class MyThread2(threading.Thread):

    def run(self):

        if mutexB.acquire():
            print(self.name+'----do2---up----')
            time.sleep(1)

        if mutexA.acquire():
            print(self.name+'----do2---down----')
            mutexA.release()

        mutexB.release()

    
mutexA = threading.Lock()
mutexB = threading.Lock()

if __name__ == '__main__':

    t1 = MyThread1()
    t2 = MyThread2()

    t1.start()
    t2.start()

import threading
import time

# python2中
from Queue import Queue

# python3中
# from queue import Queue

class Producer(threading.Thread):

    def run(self):
        global queue
        count = 0

        while True:
        
            if queue.qsize() < 1000:
            
                for i in range(100):
                    count = count +1
                    msg = '生成产品'+str(count)
                    queue.put(msg)
                    print(msg)

            time.sleep(0.5)


class Consumer(threading.Thread):

    def run(self):

        global queue

        while True:
        
            if queue.qsize() > 100:

                for i in range(3):
                    msg = self.name + '消费了'+queue.get()
                    print(msg)
                    time.sleep(1)


if __name__ == '__main__':
    queue = Queue()
    
    for i in range(500):
        queue.put('初始产品'+str(i))