14-多线程与多进程

多线程

目前市面上常见的系统，如windows、mac os、Linux都支持多线程

什么是多任务

操作系统同时执行多个任务

单核CPU如何实现多任务？

表面看，每个任务都是同时执行，实际上每个任务都在轮询着执行；
只是因为CPU调度和执行速度太快，导致我们感觉是所有任务都在同时执行

多核CPU如何实现多任务？

当任务数小于CPU核心数时，是真正的多任务
当任务数大于CPU核心数时，多余的任务会再次被分配，分配到的CPU进行轮询执行

并发与并行

并发：表面看时一起执行，但是任务数多余CPU核心数
并行：一起执行，但是任务数小于CPU数

实现多任务的方式

1.多进程方式 多操作系统而言，一个任务就是一个进程
2.多线程方式
3.协程方式
4.多进程+多线程方式

python中的多进程

multiprocessing 多进程

from multiprocessing import Process

import time


def func():
    while True:
        print("这也是一个python进程")
        time.sleep(1.5)

if __name__ == '__main__':
    print("父进程启动...")
    p = Process(target=func)
    p.start()
    while True:
        print("这是一个python进程")
        time.sleep(1)

带有参数的多进程

from multiprocessing import Process

import time


def func(str):
    while True:
        print("这也是一个%s进程"%str)
        time.sleep(1.5)

if __name__ == '__main__':
    print("父进程启动...")
    p = Process(target=func, args=("python",))
    p.start()
    while True:
        print("这是一个python进程")
        time.sleep(1)

多进程中的变量

.join() 表示父进程等待子进程结束再继续执行

每个进程都有自己的一套代码段、数据段和堆栈段，互不干扰；
也就是说父进程中的全局变量会在子进程创建时备份一份，
如果在子进程中进行更改不会影响父进程中的变量；
同样如果父进程在创建了子进程后再对全局变量进行修改，同样不会对子进程的变量造成影响

Pocess中传递参数必须为可迭代对象

from multiprocessing import Process
import time

num = 100


def func(num):
    print("子进程启动...")
    time.sleep(1)
    num += 1
    print(num)
    print("子进程结束...")


if __name__ == '__main__':

    print("父进程启动...")
    p = Process(target=func, args=(num,))
    # 此时子进程已创建，再修改父进程中的全局变量将不会影响子进程
    num += 2
    p.start()

    print("父进程结束...%d" % num)

进程池

1.进程池需要导入 multiprocessing 中的Pool
2.创建进程池时Pool()中的参数表示同时启动的进程数
如果不写则表示本机的逻辑核心数
3.进程池中进程启动不用写 start 语句
4.进程池必须先关闭才能join
5.进程池join后，父进程会等待池内所有进程执行完毕再向下执行
6.进程池内的进程启动顺序由操作系统来决定

from multiprocessing import Pool
import time, random


def func(num):
    print("子进程%d启动" % num)
    start = time.time()
    time.sleep(random.choice([1, 2, 3]))
    end = time.time()
    print("子进程%d结束，耗时%d秒" % (num, end-start))


def func1():
    print("我是一个子进程，我负责计算1+1=2")


if __name__ == '__main__':
    print("父进程启动")
    # Pool中的参数表示同时启动进程的数量，如果不写则表示本机逻辑核心数
    # 进程池中的进程启动顺序由系统来决定
    pp = Pool(2)
    # # 此处为用for循环建立多个子进程，但是子进程的功能都相同
    # for i in range(10):
    #     pp.apply_async(func, args=(i,))

    # 此处为单个建立子进程，子进程的功能可以不同
    pp.apply_async(func, args=(1,))
    pp.apply_async(func1)

    # 进程池中进程不需要写start语句
    # 进程池进行join时必须先关闭
    pp.close()
    # 进程池join后父进程会等待进程池中所有程序结束才继续执行
    pp.join()
    print("父进程结束")

多线程混乱

多个线程对同一数据进行更改时，次数越大，发生错误或线程混乱的几率越大

import threading
num = 0


def run(n):
    global num
    for i in range(1000000):
        num = num + n
        num = num - n
        # print(num)


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)

锁对象

为了确保一段代码只能由一个线程从头到尾的完整执行
我们引入了锁对象，来限制进行的并发执行,避免多线程并发引起的数据混乱
但是会大大的降低效率

import threading

# 所对象
lock = threading.Lock()
num = 0


def run(n):
    global num
    for i in range(1000000):
        """
        # 第一种写法
        # 加锁
        lock.acquire()
        num += n
        num -= n
        # 解锁
        lock.release()
        """
        # 第二种写法
        with lock:
            num += n
            num -= n


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

信号量：Semaphore

限定多线程并发数量
线程结束数量：Barrier
限定多线程的结束数量，如果数量不足，则等待，
直到数量满足要求再结束

如果二者同时使用，注意并发数量应大于结束数量
否则线程无法结束，无法继续并发，程序会一直处于等待中

import threading,time
# 设置多线程并发数量
sem = threading.Semaphore(4)
# 设置指定数量结束
bar = threading.Barrier(3)


def run():
    with sem:
        print("%s--start"%threading.current_thread().name)
        time.sleep(1)
        bar.wait()
        print("%s--end"%threading.current_thread().name)



if __name__ == '__main__':
    for i in range(10):
        t = threading.Thread(target=run)
        t.start()

初学笔记，仅供参考