Java转pyton学习笔记-进程线程协程

# 进程创建
from multiprocessing import Process
from time import sleep
import os

number = 1
def task1(s,name):
    while True:
        sleep(s)
        print('这是任务一',os.getpid(),os.getppid(),name)#pid当前进程  ppid父进程

def task2(s,name):
    while True:
        sleep(s)
        print('这是任务二',os.getpid(),os.getppid(),name)

if __name__ == '__main__':#先把主进程全部运行一遍，再重复执行子进程
    p1 = Process(target=task1, name='任务一',args=(1,'aa'))
    p1.start()
    print(p1.name)
    p2 = Process(target=task2, name='任务二',args=(1,'bb'))
    p2.start()
    print(p2.name)
    while True:
        number += 1
        sleep(0.2)
        if number==100:
            p1.terminate()
            p2.terminate()#终止进程
            break
        else:
            print(number)

    print('主进程')

# 自定义进程
class MyProcess(Process):
    def __init__(self,name):
        super(MyProcess,self).__init__()
        self.name = name
    def run(self):
        n = 1
        while True:
            print('{}--->自定义进程,n:{}'.format(n,self.name))
            n+=1

if __name__ =='__main__':
    p1 = MyProcess('进程1')
    p1.start()
    p2 = MyProcess('进程2')
    p2.start()

# 线程池
import time
from multiprocessing import Pool
from random import random
def task(task_name):
    print('开始',task_name)
    start = time.time()
    time.sleep(random()*2)
    end = time.time()
    print('{}花费{}时间'.format(task_name,(end-start)),os.getpid())

container = []
def callback_func(n):
    container.append(n)

# if __name__ == '__main__':非阻塞线程池 当进程池满时 只有其中线程有任务完成时，其他任务才会进入空闲进程执行
#     pool = Pool(5)
#     tasks = ['听音乐','吃吃','喝喝','玩玩','乐乐','哈哈','呵呵']
#     for task1 in tasks:
#         pool.apply_async(task,args=(task1,),callback=callback_func)
#     pool.close()#添加任务结束
#     pool.join()#让进程池完成任务之后主进程才会结束
#     for c in container:
#         print(c)
#     print('over!')

if __name__ == '__main__':#阻塞式线程 一次开一个线程 执行完任务结束线程  创建线程开启新任务
    pool = Pool(5)
    tasks = ['听音乐', '吃吃', '喝喝', '玩玩', '乐乐', '哈哈', '呵呵']
    for task1 in tasks:
        pool.apply(task, args=(task1,))#阻塞式
    pool.close()  # 添加任务结束
    pool.join()  # 让进程池完成任务之后主进程才会结束

    print('over!')

# 线程通信 通过一个公用的队列  生产者和消费者
import random
import threading
from queue import Queue

def produce(q):
    i = 0
    while i<10:
        num = random.randint(1,100)
        print('生产{}'.format(num))
        q.put(num)
        sleep(1)
        i+=1
    q.put(None)
    q.task_done()

def consume(q):
    while True:
        item = q.get()
        if item is None:
            break
        print('消费{}'.format(item))
        sleep(4)
    q.task_done()


if __name__ == '__main__':
    q = Queue(10)
    t1 = threading.Thread(target=produce,args=(q,))
    t2 = threading.Thread(target=consume,args=(q,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()

# 进程
import threading

def download(n):
    images = ['girl.jpg','boy.jpg','man.jpg']
    for image in images:
        print('正在下载{}'.format(image))
        sleep(n)
        print('下载{}成功'.format(image))

def listenMusic():
    musics = ['大碗宽面','土耳其冰激凌','烤面筋','烤馒头片']
    for music in musics:
        sleep(0.5)
        print('正在听{}'.format(music))

if __name__ == '__main__':
    t1 = threading.Thread(target=download, name='aa', args=(1,))
    t1.start()
    t2 = threading.Thread(target=listenMusic,name='aa')
    t2.start()


# 多线程同步
lock = threading.Lock()
list1 = [0]*10
def task1():
    lock.acquire()#阻塞  进门后关门
    for i in range(len(list1)): #做事
        list1[i] = 1
        sleep(0.5)
        print('t1')
    lock.release()#开门

def task2():
    lock.acquire()
    for i in range(len(list1)):
        print('-->',i)
        sleep(0.5)
    lock.release()

if __name__ == '__main__':
    t1 = threading.Thread(target=task1)
    t2 = threading.Thread(target=task2)
    t1.start()#让t1先运行
    t2.start()
    t1.join()
    t2.join()
    print(list1)

# 死锁 解决方法 timeout
from threading import Thread,Lock
lockA = Lock()
lockB = Lock()
class MyThread1(Thread):
    def run(self):
        if lockA.acquire():
            print(self.name+'获取A锁')
            sleep(0.1)
            if lockB.acquire(timeout=5):
                print(self.name,'获取B锁还有A锁')
                lockB.release()
            lockA.release()

class MyThread2(Thread):
    def run(self):
        if lockB.acquire():
            print(self.name+'获取B锁')
            sleep(0.1)
            if lockA.acquire(timeout=5):
                print(self.name,'获取A锁还有B锁')
                lockA.release()
            lockB.release()
if __name__ == '__main__':
    t1 = MyThread1()
    t2 = MyThread2()
    t1.start()
    t2.start()

# 协程 greenlet a-b-c-a-b-c... 人工切换
from greenlet import greenlet
def a():
    for i in range(5):
        print('A',i)
        gb.switch()
        sleep(0.1)

def b():
    for i in range(5):
        print('B',i)
        gc.switch()
        sleep(0.1)

def c():
    for i in range(5):
        print('C',i)
        ga.switch()
        sleep(0.1)

if __name__ == '__main__':
    ga = greenlet(a)
    gb = greenlet(b)
    gc = greenlet(c)

    ga.switch()

# 协程 gevent 自动切换
# import gevent
# from gevent import monkey
# monkey.patch_all()
# def a():
#     for i in range(5):
#         print('A',i)
#         sleep(0.1)
# 
# def b():
#     for i in range(5):
#         print('B',i)
#         sleep(0.1)
# 
# def c():
#     for i in range(5):
#         print('C',i)
#         sleep(0.1)
# 
# if __name__ == '__main__':
    # ga = gevent.spawn(a)
    # gb = gevent.spawn(b)
    # gc = gevent.spawn(c)
    # 
    # ga.join()
    # gb.join()
    # gc.join()