线程、进程

"""
多进程
多线程


进程：数据段，代码段，堆栈段
"""
# 执行单线程，执行死循环不会执行run()
from time import sleep


def run():
    while True:
        print("run")
        sleep(1.2)


if __name__ == "__main__":
    while True:
        print("name")
        sleep(1)


    run()




# multprocessing库
# 跨平台多进程模块，提供Process类代表一个进程对象
from multiprocessing import Process
from time import sleep


def run(str):
    while True:
        print("i am not %s"%(str))
        sleep(1.2)


if __name__ == "__main__":
    print("父进程启动")
    """ 创建子进程
    target说明进程执行的任务
    args参数 """
    p = Process(target=run, args=("poseidon",))
    # 启动进程
    p.start()


    while True:
        print("i am poseidon")
        # 创建子进程
        sleep(1)


    run()




        # os.getpid()获取当前进程id
        print("i am not %s_%s"%(str, os.getpid()))




# 子进程结束后，继续执行父进程
    print("父进程启动")
    p = Process(target=run)
    p.start()
    
    p.join()
    print("父进程结束")




## 全局变量中变量对各个进程不共享
from multiprocessing import Process
from time import sleep


num = 100
def run():
    print("子进程启动")
    global num
    num += 1
    print("子进程启动_%d"%(num))
    
if __name__ == "__main__":
    print("父进程启动")
    p = Process(target=run)
    p.start()
    p.join()
    print("父进程结束_%d"%(num))




# 进程池Pool


from multiprocessing import Process
from multiprocessing import Pool
from time import sleep
import os, random




def run(name):
    print("%d子进程启动_%s"%(name, os.getpid()))
    sleep(3)
    print("%d子进程结束_%s"%(name, os.getpid()))


if __name__ == "__main__":
    print("父进程启动")
    """ 创建多个进程
    进程池
    表示可以同时执行进程数量
    默认大小是系统核心数 """
    pp = Pool(4)
    for i in range(4):
        # 创建进程放入进程池
        pp.apply_async(run, args=(i,))




    # join前调用close，调用close后不能添加新的进程
    pp.close()
    pp.join()


    print("父进程结束_%s"%(os.getpid()))






# 进程间通信


from multiprocessing import Process, Queue
import os, time


# 通过q进行两进程之间数据传输
def write(q):
    print("启动写入子进程_%s"%(os.getpid()))
    for chr in ["A", "B", "C", "D"]:
        q.put(chr)
        time.sleep(1)
    print("结束写入子进程_%s"%(os.getpid()))


def read(q):
    print("启动读取子进程_%s"%(os.getpid()))
    while True:
        value = q.get(True)
        print("value = " + value)
    print("结束读取子进程_%s"%(os.getpid()))


if __name__ == "__main__":
    # 父进程创建队列，传递给子进程
    # q传输两进程间的数据
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))


    pw.start()
    pr.start()
    #
    pw.join()
    # pr进程是死循环，无法等待结束，强制结束
    pr.terminate()


    print("父进程结束")




## 线程
"""
线程：在一个进程内部同时运行多个子任务
    并发执行的多任务，每一个线程共享一个进程
    线程是最小的执行单元，一个进程至少包含一个线程
模块：
_thread模块，低级（底层）模块
threading模块，高级模块
"""
import threading, time


def run():
    print("子线程启动_%s"%(threading.current_thread().name))
    time.sleep(2)
    print("打印")
    print("子线程结束_%s"%(threading.current_thread().name))


if __name__ == "__main__":
    # 任何进程默认启动一个线程，称为主线程
    # threading.current_thread返回当前线程实例
    print("主线程启动_%s"%(threading.current_thread().name))
    # 创建子线程, name线程的名称
    t = threading.Thread(target=run, name="runThread")
    t.start()
    # 等待子线程结束，继续进行主线程
    t.join()
    print("主线程结束_%s"%(threading.current_thread().name))






"""线程间共享数据
任何一个变量被所有线程共享"""


import threading


num = 0
def run(n):
    global num
    for i in range(10000):
        num = num + n
        num = num - n


if __name__ == "__main__":
    t1 = threading.Thread(target=run, args=(6,))
    t2 = threading.Thread(target=run, args=(9,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print("num = ", num)




# 线程锁
# 解决数据混乱
lock = threading.Lock()


    for i in range(10000):
        # 锁
        lock.acquire()
        try:
            num = num + n
            num = num - n
        finally:
            lock.release()