day 33 线程

1.线程理论

什么是线程:线程是cpu的最小执行单位(实体),进程是操作系统的数据资源分配单位

 

2.线程的两种创建方式(重点)

查看线程的pid:使用os模块查看id,线程的id应该是相同的

3.多线程和多进程的效率对比: 

IO密集型(遇到io切换提高代码效率)和计算密集型(切换降低代码效率):切换的时候需要保存状态和切换的时间

多线程用不了多核技术,遇到纯计算的时候,多线程回避多进程的运行时间高

import time

from threading import Thread

from multiprocessing import Process

 

def f1():

    # time.sleep(1) #io密集型以后遇到的情况一遍是这样的 

    # a= 1

    # a= a+1

    # print('xxx')

    pass

if __name__ == '__main__':

    #查看一个20个多线程执行20个任务的执行时间

    t_s_time = time.time()

    t_list =[]

    for i in range(20):

        t = Thread(target=f1,)

        t.start()

        t_list.append(t)

    [tt.join() for tt in t_list]

    t_e_time = time.time()

    t_dif_time = t_e_time - t_s_time

    #查看一下20个进程执行同样的任务的执行时间

    p_s_time = time.time()

    p_list = []

    for i in range(20):

        p = Process(target=f1, )

        p.start()

        p_list.append(p)

    [pp.join() for pp in t_list]

    p_e_time = time.time()

    p_dif_time = p_e_time - p_s_time

 

    print('多线程的执行时间:', t_dif_time)

    print('多进程的执行时间:', p_dif_time)

4.线程空间是不是隔离的:共享数据可以被更改,

import time

from threading import Thread

 

num =100

def f1(n):

    time.sleep(3)

    global num

    num= 3

    print('子线程的num',num)

 

 

if __name__ == '__main__':

    t = Thread(target=f1,args=(1,))

    t.start()

    t.join()

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

 

#子线程的num 3

# 主线程中的num 3

5.守护线程

p.daemon =True  主进程的代码运行完毕,设置为守护进程的子进程会随之结束

6.锁(重点)

线程和进程的锁一样,都是牺牲了效率,保证了数据的安全

import time

from threading import Thread,Lock

 

num = 100

 

def f1(loc):

    loc.acquire()  #遇到锁,10个线程抢一个,一个进行更改数据,从并行状态更改成串行状态,牺牲的效率,保证了数据的安全

    global num   #global 只是声明变量,没有拿变量

    # num -= 1

    tmp = num

    tmp -=1

    time.sleep(0.2)

    num = tmp

    loc.release()  #解锁,把上一个更改的数据更改完成之后进行解锁,解锁之后,剩余9个在重新抢这个锁在重新更改num值,

 

 

if __name__ == '__main__':

    t_lock = Lock()

    t_list = []   #把10个线程放到一个列表,保证线程结束,主要的等待线程的结束

    for i in range(10):

        t = Thread(target=f1,args=(t_lock,))

        t.start()

        t_list.append(t)

    [tt.join() for tt in t_list]

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

 

#主线程的num 90

死锁现象(重点):

两个锁进行了嵌套,一个锁包含了另一个锁

主要在数据运算\分析的时候,注意到锁跟锁嵌套的关系,容易出现死锁现象,解决这个现象问题,出现了递归锁

 

递归锁(重点) Rlock

import time

from threading import Thread,Lock,RLock

 

def f1(locA,locB):

    print('xxxx')

    time.sleep(0.1)

    locA.acquire()

    print('f1>>>1号抢到了A锁')

    time.sleep(1)

    locB.acquire()

    print('f1>>>2号抢到了B锁')

    locB.release()

    locA.release()

 

def f2(locA,locB):

    print('22222')

    time.sleep(0.1)

    locB.acquire()

    print('f2>>>1号抢到了B锁')

    time.sleep(1)

    locA.acquire()

    print('f2>>>2号抢到了A锁')

    locB.release()

    locA.release()

 

if __name__ == '__main__':

    # locA = Lock()

    # locB = Lock()

    locA = locB = RLock()   #递归锁,维护一个计数器,acquire一次加1,release一次减1,

    t1 = Thread(target=f1, args=(locA, locB))

    t2 = Thread(target=f2, args=(locA, locB))

    t1.start()

    t2.start()

    # print(t1)

    # print(t2)

递归锁,维护一个

GIL锁(重点) 

解释器上添加的锁,互斥锁造成效率不高 

计算密集型:多进程可以应用多核技术,因为每个进程里面都有解释器程序.

计算密集型的任务,由于python多线程,不能应用多核,所以效率不高,几个线程串行执行了.

io密集型的任务:多线程的任务比多进程更有优势,

   流程:数据从硬盘发送到内存上,内存里面会加载进程到内存开辟的空间,开辟的空间里面包含cpython解释器 和py文件,cpython解释器里面包含:虚拟机和编译器,py文件里面里面的线程通过解释器的时候,解释器的GIL锁(全局解释器锁)变成串行

 

 

 

 

 

 

 

 

 

1.线程理论

什么是线程:线程是cpu的最小执行单位(实体),进程是操作系统的数据资源分配单位

 

2.线程的两种创建方式(重点)

查看线程的pid:使用os模块查看id,线程的id应该是相同的

3.多线程和多进程的效率对比: 

IO密集型(遇到io切换提高代码效率)和计算密集型(切换降低代码效率):切换的时候需要保存状态和切换的时间

多线程用不了多核技术,遇到纯计算的时候,多线程回避多进程的运行时间高

import time

from threading import Thread

from multiprocessing import Process

 

def f1():

    # time.sleep(1) #io密集型以后遇到的情况一遍是这样的 

    # a= 1

    # a= a+1

    # print('xxx')

    pass

if __name__ == '__main__':

    #查看一个20个多线程执行20个任务的执行时间

    t_s_time = time.time()

    t_list =[]

    for i in range(20):

        t = Thread(target=f1,)

        t.start()

        t_list.append(t)

    [tt.join() for tt in t_list]

    t_e_time = time.time()

    t_dif_time = t_e_time - t_s_time

    #查看一下20个进程执行同样的任务的执行时间

    p_s_time = time.time()

    p_list = []

    for i in range(20):

        p = Process(target=f1, )

        p.start()

        p_list.append(p)

    [pp.join() for pp in t_list]

    p_e_time = time.time()

    p_dif_time = p_e_time - p_s_time

 

    print('多线程的执行时间:', t_dif_time)

    print('多进程的执行时间:', p_dif_time)

4.线程空间是不是隔离的:共享数据可以被更改,

import time

from threading import Thread

 

num =100

def f1(n):

    time.sleep(3)

    global num

    num= 3

    print('子线程的num',num)

 

 

if __name__ == '__main__':

    t = Thread(target=f1,args=(1,))

    t.start()

    t.join()

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

 

#子线程的num 3

# 主线程中的num 3

5.守护线程

p.daemon =True  主进程的代码运行完毕,设置为守护进程的子进程会随之结束

6.锁(重点)

线程和进程的锁一样,都是牺牲了效率,保证了数据的安全

import time

from threading import Thread,Lock

 

num = 100

 

def f1(loc):

    loc.acquire()  #遇到锁,10个线程抢一个,一个进行更改数据,从并行状态更改成串行状态,牺牲的效率,保证了数据的安全

    global num   #global 只是声明变量,没有拿变量

    # num -= 1

    tmp = num

    tmp -=1

    time.sleep(0.2)

    num = tmp

    loc.release()  #解锁,把上一个更改的数据更改完成之后进行解锁,解锁之后,剩余9个在重新抢这个锁在重新更改num值,

 

 

if __name__ == '__main__':

    t_lock = Lock()

    t_list = []   #把10个线程放到一个列表,保证线程结束,主要的等待线程的结束

    for i in range(10):

        t = Thread(target=f1,args=(t_lock,))

        t.start()

        t_list.append(t)

    [tt.join() for tt in t_list]

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

 

#主线程的num 90

死锁现象(重点):

两个锁进行了嵌套,一个锁包含了另一个锁

主要在数据运算\分析的时候,注意到锁跟锁嵌套的关系,容易出现死锁现象,解决这个现象问题,出现了递归锁

 

递归锁(重点) Rlock

import time

from threading import Thread,Lock,RLock

 

def f1(locA,locB):

    print('xxxx')

    time.sleep(0.1)

    locA.acquire()

    print('f1>>>1号抢到了A锁')

    time.sleep(1)

    locB.acquire()

    print('f1>>>2号抢到了B锁')

    locB.release()

    locA.release()

 

def f2(locA,locB):

    print('22222')

    time.sleep(0.1)

    locB.acquire()

    print('f2>>>1号抢到了B锁')

    time.sleep(1)

    locA.acquire()

    print('f2>>>2号抢到了A锁')

    locB.release()

    locA.release()

 

if __name__ == '__main__':

    # locA = Lock()

    # locB = Lock()

    locA = locB = RLock()   #递归锁,维护一个计数器,acquire一次加1,release一次减1,

    t1 = Thread(target=f1, args=(locA, locB))

    t2 = Thread(target=f2, args=(locA, locB))

    t1.start()

    t2.start()

    # print(t1)

    # print(t2)

递归锁,维护一个

GIL锁(重点) 

解释器上添加的锁,互斥锁造成效率不高 

计算密集型:多进程可以应用多核技术,因为每个进程里面都有解释器程序.

计算密集型的任务,由于python多线程,不能应用多核,所以效率不高,几个线程串行执行了.

io密集型的任务:多线程的任务比多进程更有优势,

   流程:数据从硬盘发送到内存上,内存里面会加载进程到内存开辟的空间,开辟的空间里面包含cpython解释器 和py文件,cpython解释器里面包含:虚拟机和编译器,py文件里面里面的线程通过解释器的时候,解释器的GIL锁(全局解释器锁)变成串行