python线程与进程

多任务介绍

引入

1.现实中的多任务

看着视频敲着代码

2.计算机中的多任务

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

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

现在，多核CPU已经非常普及了，但是，即使过去的单核CPU，也可以执行多任务。由于CPU执行代码都是顺序执行的，那么，单核CPU是怎么执行多任务的呢？

答案就是操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒……这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。

真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。

并发与并行

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

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

进程

定义

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

进程本质上就是资源的集合。

一个进程有虚拟的地址空间，可执行的代码，操作系统的接口，安全的上下文(可以记录启动该进程的用户和权限等等)，唯一的进程ID、环境变量、优先级类、最小和最大的工作空间(内存空间)\

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

import os
pid=os.fork()
if pid==0:
    print('1')
else:
    print('0') 
#脚本运行结果:
yao@ubuntu:~/Desktop$ python3 fork_demo.py 
0
1

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

• 在普通的函数调用，调用一次，返回一次；

• fork()调用一次，返回两次。

  • 因为操作系统自动把当前的进程(父进程)复制一份(子进程),然后,分别在父进程和子进程内返回

fork( )子进程永远返回0,而父进程返回子进程的ID.

一个父进程可以fork出多个子进程.父进程可以记下每个子进程的ID,而子进程只需要调用getppid( )

getpid()返回当前进程id

getppid()返回父进程id

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('父子进程都可以执行这里。')
#脚本运行结果:
yao@ubuntu:~$ cd Desktop/process_demo/
yao@ubuntu:~/Desktop/process_demo$ python3 fock_id_demo.py 
我是父进程:	2720,我的子进程是:	2721
父子进程都可以执行这里。
我是子进程:	2721,我的父进程是:	2720
父子进程都可以执行这里。

线程

定义

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

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

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

线程的工作方式

假设你正在读一本书，没有读完，你想休息一下，但是你想在回来时恢复到当时读的具体进度。有一个方法就是记下页数、行数与字数这三个数值，这些数值就是execution context。如果你的室友在你休息的时候，使用相同的方法读这本书。你和他只需要这三个数字记下来就可以在交替的时间共同阅读这本书了。

线程的工作方式与此类似。CPU会给你一个在同一时间能够做多个运算的幻觉，实际上它在每个运算上只花了极少的时间，本质上CPU同一时刻只干了一件事。它能这样做就是因为它有每个运算的execution context。就像你能够和你朋友共享同一本书一样，多任务也能共享同一块CPU。

进程与线程区别

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

python中多线程的实习

1.创建一个函数传入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()
#结果:
---正在播放歌曲0------正在下载歌曲0---

---正在播放歌曲1------正在下载歌曲1---

---正在播放歌曲2------正在下载歌曲2---

---正在播放歌曲3------正在下载歌曲3---

---正在播放歌曲4------正在下载歌曲4---

可以看出,使用多线程并发操作,花费的时间要短很多(上面程序时间从10减到5)

当我们调用start()时,才会真正执行线程,执行线程中的代码

2.继承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 amThread-2@0I amThread-1@0

I amThread-2@1
I amThread-1@1
I amThread-2@2I amThread-1@2

I amThread-2@3I amThread-1@3

I amThread-2@4I amThread-1@4

python的threading.Thread类有一个run方法,用于定义线程的功能函数,可以在自己的线程类中覆盖该方法.

而创建自己的线程实例后,通过Thread的start( )方法,可以启动该线程.当该线程获得执行的机会后,

就会调用run( )方法执线程.即start( )是通过调用Thread中的run()函数执行线程的

注：

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

3.线程何时开启,何时结束

• 子线程何时开始,何时有运行

  • 当调用threading.start( )时,开启线程再运行线程的代码

• 子线程何时结束

  • 子线程把target指向的函数中的语句执行完毕后,或者线程中run代码执行完毕后,立即结束当前子进程

• 查看当前的线程数量

  • 通过threading.enumerate()可枚举当前运行的所有线程

• 主线程何时结束

  • 所有子线程执行完毕后,主线程才结束

import threading
import time
def test1():
    for i in range(2):
        time.sleep(0.89)
        print('---子线程1---%d'%i)
        print('子线程1中查看线程情况',threading.enumerate())
def test2():
    for i in range(3):
        time.sleep(0.89)
        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()
#结果:
创建线程前的线程情况 [<_MainThread(MainThread, started 17188)>]
---子线程1---0
子线程1中查看线程情况 [<_MainThread(MainThread, started 17188)>]
---子线程1---1
子线程1中查看线程情况 [<_MainThread(MainThread, started 17188)>]
---子线程2---0
子线程2中查看线程情况 [<_MainThread(MainThread, started 17188)>]
---子线程2---1
子线程2中查看线程情况 [<_MainThread(MainThread, started 17188)>]
---子线程2---2
子线程2中查看线程情况 [<_MainThread(MainThread, started 17188)>]
创建线程后的线程情况 [<_MainThread(MainThread, started 17188)>]
调用thread.start()后的线程情况 [<_MainThread(MainThread, started 17188)>]
查看当前的线程情况 [<_MainThread(MainThread, started 17188)>]

rted 17188)>]
—子线程2—2
子线程2中查看线程情况 [<_MainThread(MainThread, started 17188)>]
创建线程后的线程情况 [<_MainThread(MainThread, started 17188)>]
调用thread.start()后的线程情况 [<_MainThread(MainThread, started 17188)>]
查看当前的线程情况 [<_MainThread(MainThread, started 17188)>]