python-面向运行时性能优化-threading

一：线程基础

1> 线程状态

线程有五种状态：新建、就绪、运行、阻塞、死亡

2> 线程同步

因为线程同时运行多个任务，但实际上还是cpu以极快的速度在每个线程之间转换处理任务；对于python这种高级语言，每条语句未一次执行完成，因此，在语句执行过程中，还未结束test1任务，cpu就运行其他的线程任务test2，这可能会导致公共资源发生不好的变化,会导致数据不同步，因此引用了锁的概念，避免重要数据在处理时被打断或者其他线程篡改；

1. 锁的状态

锁有两种状态——锁定、未锁定，当锁定的时候，其他的线程执行到锁定的部分，需要请求锁，但是锁一次只供给一条线程，等这条先线程执行到释放锁的时候，其他的等待（被阻塞）的线程中，才有一条线程可以获得锁（线程进行竞争来获取锁，不知道那线程得到锁），然后继续执行、释放等，这样的话重要数据的操做会完整执行，保证了数据的同步。

线程和锁的关系

3> 线程通信-条件变量

线程同步使用了锁，保证了只让一条线程执行，其他等待，我们认为其他的线程被阻塞了，且这些线程的等待是被动的，释放锁后会立刻竞争锁；
**条件变量：**允许在不满足条件的时候，线程进入等待，当其他线程创造条件后，发出通知，线程挂起状态运行，收不到通过通知，就会一直挂着；
当一个线程得到锁定后，判断是否满足条件。如果不满足，则回到等待池（此时自动解锁），等待条件满足的通知，然后收到通知后，请求锁定，直到获得锁定，条件满足，继续执行，然后释放锁给其它线程；

挂起相对于阻塞来说，可以看为是一个主动的行为，因为如果一致不满足，及时锁释放了，被挂起的线程也不会取竞争锁

当满足某种条件后，认为需要唤醒等待线程来执行任务，就可以使用 nodify() 后者nodify_all()唤起一条或所等待池中的线程

4> 线程阻塞-之间转换

1. 阻塞分类

阻塞有三种

分类	注释
同步阻塞	指处于竞争锁定的状态，线程请求锁定时将进入这个状态，一旦成功获得锁定又恢复到运行状态；
等待阻塞	指等待其他线程通知的状态，线程获得条件锁定后，调用“等待”将进入这个状态，一旦其他线程发出通知，线程将进入同步阻塞状态，再次竞争条件锁定；
其他阻塞	指调用time.sleep()、anotherthread.join()或等待IO时的阻塞，这个状态下线程不会释放已获得的锁定;

二：threading类

1> threading介绍

介绍内容	注释
概述	threading用于提供跟线程相关的操作，线程是应用程序中工作的最小单元
threading模块提供的类	Thread、Lock、Rlock、Condition、Semaphore、Event、Timer、local
threading模块提供的 常用方法	threading.currentThreading()　　返回现在进行的线程变量；threading.enumerate()　　返回当前正在运行的所有进程的列表；threading.activeCount()　　返回活跃的线程的数量，与len(threading.enumrate())相同；

2> Thread类

Thread类是threading标准库中最重要的一个类。
你可以通过实例化Thread类，创建Thread对象，来创建线程。
你也可以通过继承Thread类创建派生类，并重写__init__和run方法，实现自定义线程对象类

1. Thread的生命周期

序列	含义
1	创建对象时，代表Thread内部被初始化
2	调用start()方法后，thread会开始运行
3	thread代码正常运行结束或者遇到异常，线程会终止。
4	可以通过Thread的is_alive()方法查询线程是否还在运行。is_alive() 返回 True 的情况是 Thread 对象被正常初始化，start() 方法被调用，然后线程的代码还在正常运行

2. 实例化Thread类

将要执行的方法，作为一个参数，在实例化Threading类的时候,作为目标直接传入

import threading
import time

def test(x, y):
    print('%s is current thread!'%threading.current_thread())
    time.sleep(2)
    print('%s is ending!'%threading.current_thread())
    print(x + y)

for i in range(4):
    thread1 = threading.Thread(target=test, name='threading '+str(i),args=(i, 5))
    thread1.start()
    time.sleep(2)
    =============
    <Thread(threading 0, started 736)> is current thread!
<Thread(threading 0, started 736)> is ending!
5
<Thread(threading 1, started 9372)> is current thread!
<Thread(threading 1, started 9372)> is ending!
6
<Thread(threading 2, started 5860)> is current thread!
<Thread(threading 2, started 5860)> is ending!
7
<Thread(threading 3, started 6916)> is current thread!
<Thread(threading 3, started 6916)> is ending!
8

3. 继承Thread类

从Thread类继承，继承的对象重写的调用run方法

import threading
import time
class ChildThread(threading.Thread):
    def __init__(self,name):
        super(ChildThread,self).__init__()  # 显式调用父类初始化函数
        self.name = name

    def run(self) -> None:
        print(self.name,'is runnig' )
        print('当前进程有======>',threading.enumerate())

for i in range(1, 3):
    thread1 = ChildThread(i)
    thread1.run()
    =============
    1 is runnig
当前进程有======> [<_MainThread(MainThread, started 708)>]
2 is runnig
当前进程有======> [<_MainThread(MainThread, started 708)>]

4. Thread构造

 Thread(group=None, target=None, name=None,
                 args=(), kwargs=None, *, daemon=None)
  注释：
group: 线程组，目前还没有实现，库引用中提示必须是None；
target: 传入目标函数的名称
name: 线程名，一般命名格式为：Thread-N (N为small decimal number)
args/kwargs: 传入目标函数的参数，格式为元组。若目标函数需传关键字参数，可直接传入构造函数关键字组成的字典，无需传到任何参数

A: start方法

import threading
import time
class ChildThread():
    def __init__(self, name):
        super(ChildThread,self).__init__()  # 显式调用父类初始化函数
        self.name = name

    def test_thread(self, func_name)-> str:
        print(f'{func_name} is running name of {threading.current_thread().name}')

thread1 = ChildThread('test')
t = threading.Thread(target=thread1.test_thread, args=('test_thread',))
t.start()
===========
test_thread is running name of Thread-1

B: run方法

import threading
import time
class ChildThread(threading.Thread):
    def __init__(self, name):
        super(ChildThread,self).__init__()  # 显式调用父类初始化函数
        self.name = name

    def run(self) -> None:
        print(self.name,'is runnig' )
        print('当前进程有======>',threading.enumerate())

    def test_thread(self, func_name)-> str:
        print(f'{func_name} is currentthread {threading.current_thread().name}')

thread1 = ChildThread('test')
thread1.start()
============
test is runnig
当前进程有======> [<_MainThread(MainThread, started 8148)>, <ChildThread(test, started 524)>]
注释：
调用继承thread类的 start()方法，默认执行run()方法，这里的run被从写；

C: