Python之进程与线程

一.进程

多任务：操作系统可以同时运行多个任务

多任务作用：效率高，不卡顿

多任务实现方法：

           1、多进程模式：启动多个进程，每个进程虽然只有一个线程，但是多个进程可以一起执行多个任务
           2、多线程模式：启动一个进程，在一个进程的内部启动多个线程，这样多个线程也可以一起执行多个任务
           3、多进程+多线程：启动多个进程，每个进程再启动多个线程
           4、协程
           5、多进程+协程

进程概念：

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体

对于操作系统来说，一个任务就是一个进程。比方说打开浏览器就是启动一个浏览器的进程，在打开一个记事本就启动一个记事本进程，如果打开两个记事本就启动两个记事本进程。

1.单进程

from time import sleep
def run():
    while True:
        print('Oh!come on ,you will be very cold!')
        sleep(1.2)

if __name__ == '__main__':
    while True:
        print('I will show you some color to see see ')
        sleep(1)
    run()

#执行结果
I will show you some color to see see 
I will show you some color to see see 
I will show you some color to see see 
I will show you some color to see see 

2.多进程

from time import sleep
from multiprocessing import Process
def run1():
        print('子进程1开始')
        sleep(3)
        print('子进程1结束')
def run2():
        print('子进程2开始')
        sleep(3)
        print('子进程3结束')
if __name__ == '__main__':
    print('主进程启动')
    p1 = Process(target=run1)
    p1.start()
    p2 = Process(target=run2)
    p2.start()
    # 父进程的结束不能影响子进程，让父进程等待子进程结束再执行父进程
    p1.join()
    p2.join()
    print('主进程结束')


#执行结果
主进程启动
子进程1开始
子进程2开始
子进程1结束
子进程3结束
主进程结束

 

3.启动大量子进程

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

def run(name):
    # os.getpid()获取当前进程的进程ID
    print("子进程%s启动--%s"%(name, os.getpid()))
    t1 = time.time()
    time.sleep(random.random()*5)
    t2 = time.time()
    print("子进程%s结束--%s--耗时%.2f" % (name, os.getpid(), t2-t1))

if __name__ == "__main__":
    print("启动父进程")
    #进程池 表示可以同时执行的进程数量
    #Pool的默认值为CPU的核心数量
    pool = Pool()
    #设置子进程数
    for i in range(5):
        # 创建进程放入进程池中统一管理
        pool.apply_async(run, args=(i,))

    # 进程池对象调用join之前必须先调用close，调用close之后就不能向进程池中添加进程了
    pool.close()
    #Pool对象调用join方法，会等待所有子进程结束在执行主进程
    pool.join()

    print("结束父进程")

二.线程

线程：
线程，有时被称为轻量进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。

多线程：多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理（Chip-level multithreading）或同时多线程（Simultaneous multithreading）处理器。 [1]  在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理（Multithreading）”。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程（台湾译作“执行绪”），进而提升整体处理性能

多线程

import threading
import random
import time

def run1(num):
    print("启动%s子线程%s"%(threading.current_thread().name, num))
    time.sleep(random.random()*5)
    print("结束%s子线程%s" % (threading.current_thread().name, num))

def run2(num):
    print("启动%s子线程%s" % (threading.current_thread().name, num))
    time.sleep(random.random()*5)
    print("结束%s子线程%s" % (threading.current_thread().name, num))


if __name__ == "__main__":
    # threading.current_thread()得到当前线程对象
    print("主线程%s启动" % threading.current_thread().name)

    #创建线程
    Thread1 = threading.Thread(target=run1, args=(1,), name="Thread1")
    Thread2 = threading.Thread(target=run2, args=(2,), name="Thread2")

    Thread1.start()
    Thread2.start()

    Thread1.join()
    Thread2.join()

    print("主线程%s结束" % threading.current_thread().name)

# 执行结果
主线程MainThread启动
启动Thread1子线程1
启动Thread2子线程2
结束Thread2子线程2
结束Thread1子线程1
主线程MainThread结束