进程，线程，多任务

多任务

谈及进程和线程之前，先要提及多任务，线程和进程是实现多任务的两种方式
多任务概念:同一时间执行多个任务
多任务的方式:

• 并发：一段时间内交替执行任务
• 并行：多核cpu处理多任务（并行才是多个任务一起执行）

进程

一个正在运行的程序或者软件就是一个进程，是操作系统资源分配的基本单位，每启动一个进程，操作系统就会给其分配一定的运行资源保证进程的运行

多进程的使用

• 进程包
• 进程类
• 进程编号
• 进程类创建实例对象的方法和属性
• 进程执行带有参数的任务

进程包

import multiprocessing

进程类

from multiprocessing import Process
import time


def sing():
    for i in range(5):
        print('sing...')
        time.sleep(2)


def dance():
    for i in range(5):
        print('dance...')
        time.sleep(2)


if __name__ == '__main__':
    sing_process = Process(target=sing, name='sing')
    dance_process = Process(target=dance)

    print('sing_process_name:', sing_process.name)  # sing
    print('dance_process_name:', dance_process.name)  # Process-2
    sing_process.start()
    dance_process.start()

进程类创建实例对象的三种方法

• process.start() : 启动子进程实例（创建子进程）
• process.join() : 等待子进程执行结束
• process.terminate(): 不管任务是否完成，立即终止子进程
  进程类创建实例对象的属性
  实例对象.name:当前进程的别名，默认为Process-N，N为从1开始递增的整数,在创建进程类的时候，参数name的值
  进程编号
  目的：验证主进程和子进程的关系，可以得知子进程是由哪个主进程创建出来的
  操作：
• 获取当前进程编号：os.getpid()
• 获取当前父进程编号：os.getppid()

from multiprocessing import Process
import os
import time


def sing():
    print('sing_pid:', os.getpid())  # 8352
    print('sing_ppid:', os.getppid())  # 14880
    for i in range(5):
        print('sing...')
        time.sleep(2)


def dance():
    print('dance_pid:', os.getpid())  # 12376
    print('dance_ppid:', os.getppid())  # 14880
    for i in range(5):
        print('dance...')
        time.sleep(2)


if __name__ == '__main__':
    print('main_pid:', os.getpid())  # 14880
    sing_process = Process(target=sing)
    dance_process = Process(target=dance)
    sing_process.start()
    dance_process.start()

进程执行带有参数的任务

• args
• kwargs

from multiprocessing import Process
import time


def sing(count):
    for i in range(count):
        print('sing...')
        time.sleep(2)


def dance(count):
    for i in range(count):
        print('dance...')
        time.sleep(2)


if __name__ == '__main__':
    sing_process = Process(target=sing, args=(5,))
    dance_process = Process(target=dance, kwargs={'count': 5})
    sing_process.start()
    dance_process.start()

线程

线程是进程中执行代码的一个分支，线程是cpu调度的基本单位

多线程的使用

• 线程包
• 线程类
• 带参数的线程

线程类

from threading import Thread
import time


def sing(count):
    for i in range(count):
        print('sing...')
        time.sleep(2)


def dance(count):
    for i in range(count):
        print('dance...')
        time.sleep(2)


if __name__ == '__main__':
    sing_thread = Thread(target=sing, args=(5,))
    dance_thread = Thread(target=dance, kwargs={'count': 5})
    sing_thread.start()
    dance_thread.start()

设置守护主进程
目的：主进程结束，子进程也随之结束
方式：

• 设置守护主进程

from multiprocessing import Process
import time


def sing():
    for i in range(5):
        print('sing...')
        time.sleep(2)


if __name__ == '__main__':
    process = Process(target=sing)
    # 设置守护主进程，主进程退出子进程直接销毁，子进程的生命周期依赖与主进程
    process.daemon = True
    process.start()
    time.sleep(4)
    print('over')

• 销毁子进程

from multiprocessing import Process
import time


def sing():
    for i in range(5):
        print('sing...')
        time.sleep(2)


if __name__ == '__main__':
    process = Process(target=sing)
    process.start()
    time.sleep(4)
    print('over')
    process.terminate()

设置守护主线程

• threading.Thread(target=show_info, daemon=True)

from threading import Thread
import time


def sing():
    for i in range(5):
        print('sing...')
        time.sleep(2)


if __name__ == '__main__':
    sing_thread = Thread(target=sing, daemon=True)
    sing_thread.start()
    time.sleep(4)
    print('over')

• 线程对象.setDaemon(True)

from threading import Thread
import time


def sing():
    for i in range(5):
        print('sing...')
        time.sleep(2)


if __name__ == '__main__':
    sing_thread = Thread(target=sing)
    sing_thread.setDaemon(True)
    sing_thread.start()
    time.sleep(4)
    print('over')

线程解决避免共享数据出错
方式：

• 线程等待

from threading import Thread

num = 0


def t1():
    for i in range(1000000):
        global num
        num += 1
    print('num:', num)


def t2():
    for i in range(1000000):
        global num
        num += 1
    print('num:', num)


if __name__ == '__main__':
    t1_thread = Thread(target=t1)
    t2_thread = Thread(target=t2)

    t1_thread.start()  # num: 1000000
    # 主线程等待第一个线程执行完成以后代码再继续执行，让其执行第二个线程
    # 线程同步： 一个任务执行完成以后另外一个任务才能执行，同一个时刻只有一个任务在执行
    t1_thread.join()
    t2_thread.start()  # num: 2000000

• 互斥锁

# 创建锁
mutex = threading.Lock()

# 上锁
mutex.acquire()

...这里编写代码能保证同一时刻只能有一个线程去操作, 对共享数据进行锁定...

# 释放锁
mutex.release()

注意：

• acquire和release方法之间的代码同一时刻只能有一个线程去操作
• 如果在调用acquire方法的时候 其他线程已经使用了这个互斥锁，那么此时acquire方法会堵塞，直到这个互斥锁释放后才能再次上锁

import threading

# 创建全局互斥锁
lock = threading.Lock()

num = 0


def t1():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global num
        num += 1
    print('num:', num)

    # 释放锁
    lock.release()


def t2():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global num
        num += 1
    print('num:', num)

    # 释放锁
    lock.release()


if __name__ == '__main__':
    t1_thread = threading.Thread(target=t1)
    t2_thread = threading.Thread(target=t2)
    t1_thread.start()  # num: 1000000
    t2_thread.start()  # num: 2000000

进程和线程对比方向

1.关系对比

• 线程是依附在进程里面的，没有进程就没有线程。
• 一个进程默认提供一条线程，进程可以创建多个线程

2.区别对比

• 进程之间不共享全局变量
• 线程之间共享全局变量，但是要注意资源竞争的问题，解决办法: 互斥锁或者线程同步
• 创建进程的资源开销要比创建线程的资源开销要大
• 进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
• 线程不能够独立执行，必须依存在进程中
• 多进程开发比单进程多线程开发稳定性要强

3.优缺点对比

• 进程优缺点:
  优点：可以用多核
  缺点：资源开销大
• 线程优缺点:
  优点：资源开销小
  缺点：不能使用多核