码迷,mamicode.com
首页 > 编程语言 > 详细

python并发编程之线程(创建线程,锁(死锁现象,递归锁),GIL锁)

时间:2019-01-14 17:18:18      阅读:143      评论:0      收藏:0      [点我收藏+]

标签:相同   super   解释   range   1.5   info   daemon   []   效率   

什么是线程

进程:资源分配单位

线程:cpu执行单位(实体),每一个py文件中就是一个进程,一个进程中至少有一个线程

线程的两种创建方式:

from multiprocessing import Process
def f1(n):
    print(n,号线程)

if __name__ == __main__:
    t1 = Thread(target=f1,args=(1,))
    t1.start()
    print(主线程

from threading import Thread
class MyThread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name = name

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

if __name__ == __main__:

    t = MyThread(haha)
    t.start()
    print(主线程结束)

 

线程的创建和销毁,相对于进程来说开销特别小

线程之间资源共享,共享的是同一个进程中的资源,  资源共享就涉及到数据安全问题,加锁来解决

 

线程锁

From threading import Thread,Lock

def f1: 

  Loc.acquire()

  代码

  Loc.release()

main

  Loc = Lock()

  T = thread(target=f1,args=(loc,)

from multiprocessing import Queue
import queue
import time
from threading import Lock,Thread

num = 100
def f1(loc):
    loc.acquire()
    global num
    tmp = num
    tmp -= 1
    time.sleep(0.001)
    num = tmp
    loc.release()

if __name__ == __main__:

    t_loc = Lock()
    t_list = []
    for i in range(10):
        t = Thread(target=f1,args=(t_loc,))
        t.start()
        t_list.append(t)
    [tt.join() for tt in t_list]
    print(主线的num,num)

锁:牺牲了效率,保证了数据安

死锁现象(天长地久,永不分离):

出现在锁嵌套的时候,双方互相抢对方已经拿到的锁,导致双方互相等待,这就是死锁现象

import time
from threading import Thread,Lock,RLock

def f1(locA,locB):
    locA.acquire()
    print(f1>>1号抢到了A锁)
    time.sleep(1)
    locB.acquire()
    print(f1>>1号抢到了B锁)
    locB.release()

    locA.release()
def f2(locA,locB):
    locB.acquire()

    print(f2>>2号抢到了B锁)

    locA.acquire()
    time.sleep(1)
    print(f2>>2号抢到了A锁)
    locA.release()

    locB.release()
if __name__ == __main__:
    locA = Lock()
    locB = Lock()
    t1 = Thread(target=f1,args=(locA,locB))
    t2 = Thread(target=f2,args=(locA,locB))
    t1.start()
    t2.start()

递归锁:

解决死锁现象

Rlock  首先本身就是个互斥锁,维护了一个计数器,每次acquire就+1,release就-1,当计数器为0的时候,大家才能抢这个锁

 

import time
from threading import Thread, Lock, RLock

def f1(locA, locB):
    locA.acquire()
    print(f1>>1号抢到了A锁)
    time.sleep(1)
    locB.acquire()
    print(f1>>1号抢到了B锁)
    locB.release()
    locA.release()

def f2(locA, locB):
    locB.acquire()
    print(f2>>2号抢到了B锁)
    locA.acquire()
    time.sleep(1)
    print(f2>>2号抢到了A锁)
    locA.release()
    locB.release()

if __name__ == __main__:

    locA = locB = RLock()  
    t1 = Thread(target=f1, args=(locA, locB))
    t2 = Thread(target=f2, args=(locA, locB))
    t1.start()
    t2.start()

 

守护线程:

守护线程:等待所有非守护线程的结束才结束

守护进程:主进程代码运行结束,守护进程就随之结束

 

import time
from threading import Thread
from multiprocessing import Process

def f1():
    time.sleep(2)
    print(1号线程)
def f2():
    time.sleep(3)
    print(2号线程)

if __name__ == __main__:
    t1 = Thread(target=f1,)
    t2 = Thread(target=f2,)
    t2.daemon = True
    t1.start()
    t2.start()
    print(主线程结束)

GIL锁 :

  cpython解释器上的一把互斥锁,当线程需要进入cpu做运算时必须一个一个经过GIL锁

 技术分享图片

线程的事件,信号量 与进程的事件,信号量 用法相同.

python并发编程之线程(创建线程,锁(死锁现象,递归锁),GIL锁)

标签:相同   super   解释   range   1.5   info   daemon   []   效率   

原文地址:https://www.cnblogs.com/fu-1111/p/10267714.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!