python进程线程-21

2.线程进程

1.多种任务介绍

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）：是计算机系统中能同时执行两个或更多个处理的一种计算方法。并行处理可同时工作于同一程序的不同方面。并行处理的主要目的是节省大型和复杂问题的解决时间。

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

2.进程

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

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

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

进程的创建—fork（）

python的os模块封装了常见的系统调用函数，其中包括fork（）

在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('父子进程都可以执行')

3.线程

线程是操作系统能够运算调度的最小单位。线程被包含在进程当中，是进程中的实际运作单位。一条线程是进程中一个单一顺序的控制流，一个进程可以并发多个线程，每条线程并行执行的不同的任务。

一条线程是一个execution context（执行上下文）,即一个cpu执行时所需的一串指令。

线程的工作方式

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

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

进程与线程的区别

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

import threading
import time
class Thread_1(threading.Thread):
    def run(self):
        for i in range(5):
            time.sleep(1)
            print('正在下载歌曲%d'.center(20, '-') % i)
            time_1()

class Thread_2(threading.Thread):
    def run(self):
        for i in range(5):
            time.sleep(1.2)
            print('正在播放歌曲%d'.center(20, '-') % i)
            time_1()


def time_1():
    tp_s = time.localtime()
    print(time.strftime('%Y-%m-%d %X', tp_s))

def main():
    #创建两个线程
    t1=Thread_1()
    t2=Thread_2()

    t1.start()
    t2.start()
    t1.join()#阻塞主线程
    t2.join()

if __name__=='__main__':
    main()
'''
------正在下载歌曲0------
2019-08-06 16:16:00
------正在播放歌曲0------
2019-08-06 16:16:01
------正在下载歌曲1------
2019-08-06 16:16:01
------正在播放歌曲1------
2019-08-06 16:16:02
------正在下载歌曲2------
2019-08-06 16:16:02
------正在播放歌曲2------
2019-08-06 16:16:03
------正在下载歌曲3------
2019-08-06 16:16:03
------正在播放歌曲3------
2019-08-06 16:16:04
------正在下载歌曲4------
2019-08-06 16:16:04
------正在播放歌曲4------
2019-08-06 16:16:05
'''

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

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

线程何时开启，何时结束

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

demo

t1=threading.Thread(target1=test1)
t2=threading.Thread(target2=test2)
#枚举线程情况
print(threading.enmerate())

4.多线程-共享全局变量

4.1多线程可能遇到的问题·

假设有两个线程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
        time.sleep(0.1)
        print('in work1,g_num is %d'.center(20, '-') % g_num)
def work2(num):
    global g_num
    for i in range(num):
        g_num+=1
        time.sleep(0.1)
        print('in work2,g_num is %d'.center(20, '-') % g_num)

def main():

    print('线程进入前g_num is', 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('线程最终结果g_num is',g_num)

main()

同步问题

代码运行速度过快，而线程只是同一时间段同时运行，所以有一定内部先后状态

解决方法—>上锁

4.2互斥锁

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

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

说明

• blocking
  • True，会被阻塞，直到获取为止
  • Flase，则不会被阻塞

import threading
import time
g_num=0

def work1(num):
    global g_num
    for i in range(num):
        #mutex.acquire()
        g_num += 1
        #mutex.release()
    print('in work1,g_num is %d'.center(20, '-') % g_num)

def work2(num):
    global g_num
    for i in range(num):
        #mutex.acquire()
        g_num += 1
        #mutex.release()
    print('in work2,g_num is %d'.center(20, '-') % g_num)


if __name__ == '__main__':
    mutex = threading.Lock()
    print('线程进入前g_num is', g_num)
    t1 = threading.Thread(target=work1, args=(100000,))
    t2 = threading.Thread(target=work2, args=(100000,))
    t1.start()
    t2.start()
    while len(threading.enumerate())!=1:
        time.sleep(1)
    print('线程最终结果g_num is',g_num)