多任务
谈及进程和线程之前,先要提及多任务,线程和进程是实现多任务的两种方式
多任务概念:同一时间执行多个任务
多任务的方式:
- 并发:一段时间内交替执行任务
- 并行:多核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.优缺点对比
- 进程优缺点:
优点:可以用多核
缺点:资源开销大 - 线程优缺点:
优点:资源开销小
缺点:不能使用多核