Python 进程 线程

进程

进程概述

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

• 优点
  • 稳定性高，一个进程奔溃，不会影响其他进程
• 缺点
  • 创建进程开销比较大
  • 操作系统同时运行的进程数目是有限的

进程的创建

linux下 使用 fork 函数创建进程 os模块的fork
windows 使用 multiprocessing模块

python中进程操作

multiprocess.Process模块

process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。

语法：Process([group [, target [, name [, args [, kwargs]]]]])

由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）。

注意：1. 必须使用关键字方式来指定参数；2. args指定的为传给target函数的位置参数，是一个元祖形式，必须有逗号。

参数介绍：

group：参数未使用，默认值为None
target：表示调用对象，即子进程要执行的任务。
args：表示调用的位置参数元祖。
kwargs：表示调用对象的字典。如kwargs = {‘name’:Jack, ‘age’:18}。
name：子进程名称。

实例：

from multiprocessing import Process
import time
import os


def task1(s, name):
    while True:
        time.sleep(s)
        print('任务一', os.getpid(), 'father:', os.getppid(), name)


def task2(s, name):
    while True:
        time.sleep(s)
        print('任务二', os.getpid(), 'father:', os.getppid(), name)


if __name__ == '__main__':
    # 子进程
    p1 = Process(target=task1, name='no1', args=(1, 'aa'))
    p1.start()
    p2 = Process(target=task2, name='no2', args=(2, 'bb'))
    p2.start()

    print('主进程打印')

运行结果：

主进程打印
任务一 21968 father: 21967 aa
任务二 21969 father: 21967 bb
任务一 21968 father: 21967 aa
任务一 21968 father: 21967 aa
任务二 21969 father: 21967 bb
任务一 21968 father: 21967 aa
任务一 21968 father: 21967 aa
任务二 21969 father: 21967 bb

自定义进程

主要是去重写Process中的run方法

进程池

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态生成多个进程

但是如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing中的Pool方法

初始化Pool时，可以指定最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；如果池中的进程数已经达到最大进程数，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来执行

pool = Pool(max) 创建进程池对象
pool.apply() 阻塞式
pool.apply_async() 非阻塞式
pool.close()
pool.join() 让主进程让步

非阻塞式

from multiprocessing import Pool
import time
import random
import os

def task(task_name):
    print("开始任务：", task_name)
    start_time = time.time()
    time.sleep(random.random() * 2)
    end_time = time.time()
    # print('完成任务: {} 用时: {}, 进程id: {}'.format(task_name, (end_time - start_time), os.getpid()))
    return '完成任务: {} 用时: {}, 进程id: {}'.format(task_name, (end_time - start_time), os.getpid())

back_list = []
def back_fun(n):
    back_list.append(n)

if __name__ == '__main__':
    pool = Pool(5)  # 创建最大为5个进程的进程池
    tasks = ['打游戏', '做饭', '吃饭', '上班', '洗衣服', '跑步', '散步']

    for i in tasks:
        # 非阻塞式
        pool.apply_async(task, args=(i,), callback=back_fun)

    pool.close()
    pool.join()

    for i in back_list:
        print(i)
    print('主进程打印')

运行结果

开始任务： 打游戏
开始任务： 做饭
开始任务： 吃饭
开始任务： 上班
开始任务： 洗衣服
开始任务： 跑步
开始任务： 散步
完成任务: 吃饭 用时: 0.29435229301452637, 进程id: 24453
完成任务: 上班 用时: 0.5891604423522949, 进程id: 24454
完成任务: 洗衣服 用时: 0.76263427734375, 进程id: 24455
完成任务: 做饭 用时: 0.9874026775360107, 进程id: 24452
完成任务: 散步 用时: 0.5238707065582275, 进程id: 24454
完成任务: 打游戏 用时: 1.2142186164855957, 进程id: 24451
完成任务: 跑步 用时: 1.339735746383667, 进程id: 24453
主进程打印

非阻塞式：全部添加到队列中，立刻返回，并没有等待其他的进程完毕，但是回调函数是等待任务完成后调用，调用结束后，进程任务完成，未完成的任务里面添加到完成过的进程中继续当前任务

阻塞式

pool = Pool(5)
pool.apply() # 无回调方法

添加一个执行一个任务，当前任务未结束，下一个无法进入到池中

进程通讯 Queue队列

queue队列满了，就会造成后面的队列阻塞，除非有空的空间，才可以添加到队列

from multiprocessing import Process
from multiprocessing import Queue
from time import sleep

def download(q):
    images = ['a.jpg', 'b.jpg', 'c.jpg']
    for image in images:
        print('正在下载:', image)
        sleep(0.5)
        q.put(image)

def getfile(q):
    while True:
        try:
            file = q.get(timeout=2)
            print('{}保存成功'.format(file))
        except:
            print('下载完成')
            break

if __name__ == '__main__':
    q = Queue(5)
    p1 = Process(target=download, args=(q,))
    p2 = Process(target=getfile, args=(q,))
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    print('主进程')

运行结果：

正在下载: a.jpg
正在下载: b.jpg
正在下载: c.jpg
a.jpg保存成功
b.jpg保存成功
c.jpg保存成功
下载完成
主进程

线程

线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程

• 优点
  • 使用线程可以把占据长时间的程序中的任务放在后台处理
  • 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理速度
  • 程序的运行速度可能更快
  • 在一些等待的任务实现上如用户输入，文件读写和网络收发数据等，这种情况下我们可以释放一些资源内存

创建线程

python线程模块：threading

from threading import Thread
import time
class Sayhi(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        time.sleep(2)
        print('%s say hello' % self.name)


if __name__ == '__main__':
    t = Sayhi('Frank')
    t.start()
    print('主线程')

线程的状态：新建 就绪 运行 阻塞 结束

线程可以共享全局变量

GIL 全局解释器锁

from threading import Thread

n = 0

def task1():
    global n
    for i in range(1000000):
        n += 1
    print('task1的n值:{}'.format(n))

def task2():
    global n
    for i in range(1000000):
        n += 1
    print('task2的n值:{}'.format(n))

if __name__ == '__main__':
    t1 = Thread(target=task1)
    t2 = Thread(target=task2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print('最后的n值:{}'.format(n))

运行结果：

task1的n值:1192045
task2的n值:1491261
最后的n值:1491261

这个示例没有出现想要的结果，正确的结果应该为2000000，这是因为python在线程运算会自动加一把锁**(GIL)**,但是在密集型运算时，会将这个锁释放掉了，就导致运算过程中调用了重复的赋值，出现了数据的不安全，这时候就需要对多个线程进行同步

线程同步

如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。如下：

多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。

考虑这样一种情况：一个列表里所有元素都是0，线程"set"从后向前把所有元素改成1，而线程"print"负责从前往后读取列表并打印。

那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半0一半1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。

锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如"print"获得锁定了，那么就让线程"set"暂停，也就是同步阻塞；等到线程"print"访问完毕，释放锁以后，再让线程"set"继续。

经过这样的处理，打印列表时要么全部输出0，要么全部输出1，不会再出现一半0一半1的尴尬场面。

import threading
import time

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print ("开启线程： " + self.name)
        # 获取锁，用于线程同步
        threadLock.acquire()
        print_time(self.name, self.counter, 3)
        # 释放锁，开启下一个线程
        threadLock.release()

def print_time(threadName, delay, counter):
    while counter:
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

threadLock = threading.Lock()
threads = []

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()

# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)

# 等待所有线程完成
for t in threads:
    t.join()
print ("退出主线程")