Python第15天笔记——进程、线程

多任务介绍

1、现实中的多任务

2、计算机中的多任务

计算机中的多任务是指，操作系统同时完成多项任务的处理。此处同时是指同一个时间段内，而非某个瞬时时间点。

多任务处理是指，用户在同一时间端内运行多个应用程序，每个应用程序就可以称之为一个任务。

并发与并行

• 并发处理(concurrency Processing)：指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机(CPU)上运行，但任一个时刻点上只有一个程序在处理机(CPU)上运行
• 并行处理（Parallel Processing）：是计算机系统中能同时执行两个或更多个处理的一种计算方法。并行处理可同时工作于同一程序的不同方面。并行处理的主要目的是节省大型和复杂问题的解决时间。

并发的关键是你有处理多个任务的能力，不一定要同时。并行的关键是你有同时处理多个任务的能力。所以说，并行是并发的子集

进程

进程：一个程序的执行实例，每个进程提供执行程序所需的所有资源

进程本质上是资源的集合

一个进程有虚拟的地址空间、可执行的代码、操作系统的接口、安全的上下文（记录启动该进程的用户和权限等）、唯一的进程ID、环境边浪、优先级类、最小和最大的工作空间（内存空间），还要至少有一个线程。

进程创建：fork()

python的os模块封装了常见的系统调用函数，其中包括fork()，可以让我们在程序中轻松地创建于进程。

import os

pid =os.fork()
if pid == 0:
        print("zhejiang university")
else:
        print("citycollege")

在Unix/Linux中，提供了fork()系统函数。

• 普通的函数调用，调用一次返回一次；
• fork()调用一次，返回两次。
  • 因为操作系统自动把当前的进程（父进程）复制一份（子进程），然后分别在父进程和子进程内返回。

fork()子进程永远返回0，而父进程返回子进程的ID。

一个父进程可以fork出很多子进程。父进程可以记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。

• getpid()：返回当前进程标识
• getppid()：返回父进程标识

import os
pid=os.fork()
if pid<0:
    print("fork 调用失败")
elif pid==0:
    print("我是子进程：\t%s,我的父进程是：\t%s"%(os.getpid(),os.getppid()))
else:
    print("我是子进程：\t%s，我的父进程是：\t%s"%(os.getpid(),pid))
print("父子进程都可以实现在这里")

线程

线程是操作系统能够运算调度的最小单位。线程被包含在进程之中，是进程中的实际运作单位。

一条线程是进程中一个单一顺序的控制流，一个进程可以并发多个线程，每条线程并行执行的不同的任务。

一条线程是一个execution context(执行上下文)，即一个CPU执行时所需要的一串指令。

进程和线程的区别

• 同一进程中的线程共享同一内存空间，但是进程之间是独立的。
• 同一个进程中的所有线程的数据共享，进程之间的数据是独立的。
• 对主线程的修改可能影响其他线程的行为，但是父进程的修改（除了删除以外）不会影响其他子进程。
• 线程是一个上下文的执行指令，而进程则是与运算相关的一簇资源。
• 同一个进程的线程之间可以直接通信，但是进程之间的交流需要借助中间代理来实现。
• 创建新的线程很容易，但是创建新的进程需要对父进程做一次复制。
• 一个线程可以操作同一进程的其他线程，但是进程只能操作其子进程。
• 线程启动速度快，进程启动速度慢（但是两者运行速度没有可比性）。

Python中多线程的实现

• 创建一个函数传入Thread对象中

import threading
import time
def download_music():
    for i in range(5):
        time.sleep(1)
        print("---正在下载歌曲%d---"%i)
def play_music():
    for i in range(5):
        time.sleep(1)
        print("---正在播放歌曲%d---"%i)
def main():
    #创建两个线程对象,target指向新开启的线程要执行的函数
    t1=threading.Thread(target=download_music)
    t2=threading.Thread(target=play_music)

    t1.start()
    t2.start()
    
if __name__=='__main__':
    main()
    
# download_music()
# play_music()

#输出结果：
---正在播放歌曲0---
---正在下载歌曲0---
---正在下载歌曲1---
---正在播放歌曲1---
---正在下载歌曲2---
---正在播放歌曲2---
---正在下载歌曲3---
---正在播放歌曲3---
---正在下载歌曲4---
---正在播放歌曲4---

1、可以明显看出使用多线程并发的操作，花费时间要短得多

2、当我们调用start()时，才会真正执行线程以及线程中的代码。

继承Thread类，创建一个新的class，将要执行的代码写到run函数里。

import threading
import time
#自定义类，threading.Thread
class MyThread(threading.Thread):
    def run(self):
        for i in range(5):
            time.sleep(1)
            #name保存的是当前线程的名字
            msg="I am "+self.name+' @ '+str(i)
            print(msg)
if __name__=='__main__':
    t1=MyThread()
    t2=MyThread()
    t1.start()
    t2.start()
    
#输出结果：
I am Thread-1 @ 0
I am Thread-2 @ 0
I am Thread-1 @ 1
I am Thread-2 @ 1
I am Thread-1 @ 2
I am Thread-2 @ 2
I am Thread-1 @ 3
I am Thread-2 @ 3
I am Thread-1 @ 4
I am Thread-2 @ 4

Python的threading.Thread类有一个run方法，用于定义线程的功能函数，可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过Thread的start()方法，可以启动该线程。当该线程获得执行的机会时，就会调用run()方法执行线程。

import threading
import time
#自定义类，threading.Thread
class MyThread(threading.Thread):
    def run(self):
        for i in range(5):
            time.sleep(1)
            #name保存的是当前线程的名字
            msg="I am "+self.name+' @ '+str(i)
            print(msg)
def test():
    for i in range(5):
        t=MyThread()
        t.start()
if __name__=='__main__':
    test()

#输出结果：
I am Thread-1 @ 0
I am Thread-3 @ 0
I am Thread-2 @ 0
I am Thread-5 @ 0
I am Thread-4 @ 0
I am Thread-1 @ 1
I am Thread-3 @ 1
     ......
I am Thread-5 @ 3
I am Thread-4 @ 3
I am Thread-1 @ 4
I am Thread-2 @ 4
I am Thread-3 @ 4
I am Thread-4 @ 4
I am Thread-5 @ 4

线程何时开启，何时结束。

• 子线程何时开始，何时运行
  • 当调用thread.start()时，开启线程，再运行线程的代码。
• 子线程何时结束
  • 子线程把target指向的函数中的语句执行完毕后，或者线程中run代码执行完毕后，立即结束当前子进程
• 查看当前的线程数量
  • 通过threading.enumerate()可枚举当前运行的所有线程
• 主线程何时结束
  • 所有子线程执行完毕后，主线程才结束

注：

threading.currentThread(): #返回当前的线程变量。 
threading.enumerate(): #返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。 
threading.activeCount(): #返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

#demo:

import threading
import time

def test1():
    for i in range(5):
        time.sleep(1)
        print("---子线程1---%d"%i)
        print("子线程1中查看线程情况",threading.enumerate())
def test2():
    for i in range(10):
        time.sleep(1)
        print("---子线程2---%d" % i)
        print("子线程2中查看线程情况", threading.enumerate())
def main():
    #threading.enumerate():枚举当前的所有进程
    print("创建线程之前的线程情况",threading.enumerate())

    #创建线程对象
    t1=threading.Thread(target=test1)
    t2 = threading.Thread(target=test2)
    time.sleep(1)

    print("创建线程之后的线程情况",threading.enumerate())

    t1.start()
    t2.start()
    time.sleep(1)
    print("调用了thread.start()之后的线程情况",threading.enumerate())
    t2.join() #当t2线程执行完后，再执行后续的代码
    print("查看当前线程",threading.enumerate())
    
if __name__=='__main__':
    main()

多线程可能遇到的问题

假设有两个线程t1和t2，都要对一个变量g_num进行运算(+1)，两个线程t1和t2分别对g_num各加10次，g_num的最终结果？

import threading
import time

g_num=0
def work1(num):
    global g_num
    for i in range(num):
        g_num+=1
    print("---in work1,g_num is %d---"%g_num)

def work2(num):
    global g_num
    for i in range(num):
        g_num+=1
    print("---in work2,g_num is %d---"%g_num)

print("---线程创建之前g_num:%d"%g_num)
t1=threading.Thread(target=work1,args=(10,))
t2=threading.Thread(target=work2,args=(10,))
t1.start()
t2.start()
while len(threading.enumerate())!=1:
    time.sleep(1)
print("2个线程对同一个变量操作之后的最终结果为：%d"%g_num)

#输出结果
---线程创建之前g_num:0
---in work1,g_num is 10---
---in work2,g_num is 20---
2个线程对同一个变量操作之后的最终结果为：20

在num=0时，t1取得num=0，此时系统把t1调度为“sleeping"的状态，t2转换为”runing"的状态，t2也获得num=0。然后t2对得到的值+1，并赋值给num，num=1。然后系统又将t2调度为“sleeping"的状态，把t1转换为"running"，线程t1又把他之前得到的0加1后赋值给num。这种情况，明明两个线程都完成一次+1工作，但结果还是num=1。

如果我们将两个进程的参数调整为1000000，多次运行，结果不同:

t1=threading.Thread(target=work1,args=(1000000,))
t2=threading.Thread(target=work2,args=(1000000,))

#输出结果：
---线程创建之前g_num:0
---in work1,g_num is 1110922---
---in work2,g_num is 1323012---
2个线程对同一个变量操作之后的最终结果为：1323012

说明多个线程同时对一个全局变量进行操作，会出现资源竞争问题，从而数据结果会不准确。导致线程安全问题。

同步

同步，就是协同步调。按照预定的先后次序进行运行。

进程和线程同步，可以理解为进程或者线程A和B一块配合，A执行一定程度时需要依赖B的某个结果，于是停下来，让B运行，B开始运行，再将结果给A，A再继续操作。如此往复，直到程序结束。

计算错误的解决

通过”线程同步“进行解决

思路：

• 系统调度t1，获取num=0，此时上一把锁，即不允许其他操作num
• 对num的值加1
• 解锁，其他num的值为1，其他线程就可以使用num了。此时num=1
• 同理，其他线程在对num修改时，也要先上锁，处理完后在解锁。在上锁的过程中，不允许其他线程访问。就保证了数据的正确性。

互斥锁

当多个线程几乎同时修改某个共享数据时，需要进行同步控制。

线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制就是引入互斥锁。

互斥锁为我们的资源引入一个状态：锁定/非锁定

某个线程要更改共享数据时，先将其锁定，此时资源的状态为锁定，其他线程不能对其更改。直到该线程释放资源，资源状态变为”非锁定“状态，其他线程才能再次锁定该资源。

互斥锁，保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

在threading模块里，定义了lock()类，可以方便的处理锁定。

mutex=threading.Lock() #创建锁
mutex.acquire(blocking) #锁定
mutex.release()#释放

说明：

• blocking
  • True，则当前线程堵塞，直到获取这个锁为止。（如未指定，则默认为True)
  • False，则线程不会被堵塞

死锁

在线程间共享多个资源时，如果两个线程分别占有一部分资源，并且同时等待对方的资源，就会造成死锁。

死锁一般很少发生，但一旦发生就会造成应用停止响应。

描述了一个两个固定大小缓冲区的线程——即所谓的”生产者“和”消费者“，在实际运行时会发生的问题。

生产者的主要作用，生成一定量的数据放在缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。

整个问题关键是，生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区空时消耗数据。

1、队列，先进先出

2、栈，先进后出

Python中的queue（py3）（py2,Queue），模块提供了一个同步的、线程安全的队列类，包括先入先出（FIFO）队列Queue和后入先出（LIFO）队列LifoQueue和优先级队列PriorityQueue。

这些队列实现了锁原语（原子操作，要么不做，要么做完），可以在线程中直接使用。

可以使用队列来实现线程间的同步。

Linux,Windows,MacOS,操作系统，基于Unix发展而来。

linus Torwards