线程

线程理论

　　什么是线程：指令的执行过程。

　　　　　　　　在进程中存在线程，进程如果没有线程无法运行，进程只是负责提供内存资源，线程真正进入CPU，是CPU最小的运行单位。多线程就是为了一个进程执行多个任务。

　　　　　　　　线程的创建销毁被进程快，且不像进程那样内存隔离，可以不需要额外操作就可以实现数据共享。

　　　　　　　　并发的时候，多进程加多线程；多核中也可以应用多线程。

线程的两种创建方式（重点）main可写可不写

from threading import Thread
第一种
def f1(n):
    print(1+n)

def f2(n):
    print(2)

if __name__ == '__main__':
    t1 = Thread(target=f1,args=(0,))  #与进程创建相同
    t2 = Thread(target=f2,args=(0,))  #与进程创建相同
    t1.start()
    t2.start()
print('主线程')
第二种
class MyThread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        print(self.name)

if __name__ == '__main__':
    t= MyThread('cc')
    t.start()
    print('主线程')

查看线程pid线程(了解)

　　os.getpid()，显示都是同一个进程号

线程可以直接数据共享             等待线程执行完毕的方法为join（），用法同进程

与进程效率对比      创建时间差了将近百倍

线程空间不是隔离的

　　Io密集型切换提高代码效率；计算密集型切换降低代码效率。

　　计算密集型，运行时间加长，此时多线程无法应用多核技术，所有多线程此时反而比多进程慢

守护线程

　　守护线程等待所有非守护线程结束才结束，一旦别人都结束，而守护进程没结束的话也自杀

　　进程只守护主进程

线程锁/互锁（重点）

from threading import Lock,Thread
import time

num = 100
def f1():
    global num
    temp = num
    temp -= 1
    time.sleep(1)
    num = temp

if __name__ == '__main__':
    t_list = []

    for i in range(10):
        t = Thread(target=f1,)
        t.start()
        t_list.append(t)

    [t.join() for tt in t_list]

    print('主线程的num：',num)
此时无法得到90，十个线程的操作在相同，瞬间开启，
每个人线程拿到的temp可能都是100，最后赋值回去为99，可能是拿到99，变成了99

num = 100


def f1(loc):
    global num   #只是声明一个变量，不会拿到数据，不存在赋值
    loc.acquire()
    temp = num
    temp -= 1
    time.sleep(0.1)
    num = temp
    loc.release()


if __name__ == '__main__':
    t_list = []
    t_loc = Lock()
    for i in range(10):
        t = Thread(target=f1,args=(t_loc,) )
        t.start()
        t_list.append(t)

    [t.join() for tt in t_list]

    print('主线程的num：', num)

    #加锁，用法同进程锁

死锁（重点）

　　在锁的代码中再完成地嵌套一个锁时发生，

　　A中嵌套一个完整的B，B中嵌套一个完整的A，两个在想抢对方已有的锁的时候都会卡死，相互锁死

递归锁（重点）

　　破除死锁，同一把锁多个形式，RLock（）

　　内含计数器，创建一次就加一，释放一个就减一，为零才可以抢

GIL锁：

　　在全局的cpython解释器上加的一把锁

　　解释器用于解释自己的代码为二进制
       同一时间，只能有一个线程可以进入cpython解释器，导致py不能使用多核技术。想多线程并发依旧是可以搞的，但是就需要开多进程来实现了，因为就是又多开了一个解释器。
        线程可以节约io密集型程序的时间，计算密集型则不行。一般进程按照cpu的个数开。
　　子进程不能input，因为输入台只能由主进程使用，输出内容各个进程都可以，但是并发输出可能会打印混乱。 子线程可以输入，因为同属一个进程。