day34:线程&守护线程&线程锁&事件

def func(num):
    time.sleep(random.uniform(0.1,1))
    print("当前进程{},参数是{}".format(os.getpid(),num))


for i in range(10): # 在一个进程资源中创建了十个线程
    t = Thread(target=func,args=(i,))
    t.start()

print(os.getpid())

 func(num):
    if __name__ == __main__:
     多线程
    lst = []
     记录开始时间
    startime = time.time()
    in range(1000):
        t = Thread(target=func,))
        t.start()
        lst.append(t)

     等到所有的子线程执行完毕
    in lst:
        i.join()

     计算结束时间
    endtime =多线程执行时间",(endtime - startime))  0.27

:
    lst = []
    startime =):
        t = Process(target=func,1)">多进程执行时间 63.30

num = 1000
 func():
    global num
    num -= 1
    
):
    t = Thread(target=func)
    t.start()
    
print(num)
    

class MyThread(Thread):
    def __init__(self,name):
         手动调用父类的构造方法
        super().()
        self.name = name
        
     run(self):
        time.sleep(1)
        当前进程号码是{},名字是{}:
    t = MyThread(当前是一个线程)
    t.start()
    主线程执行结束 ... ")

 func():
    time.sleep(1)

:
    t = Thread(target=func)
    t.start()
     检测线程是否仍然存在
    print(t.is_alive())  True
     获取线程名字
    print(t.getName())   Thread-1
     设置线程名字
    t.setName(xboyww)
    print(t.getName())  xboyww

子线程的线程id{}.format(currentThread().ident))

:
    Thread(target=func).start()
    主线程的线程id{}".format(currentThread().ident))

.format(currentThread().ident))
    time.sleep(0.5)


in range(10):
        Thread(target=func).start()
    lst = enumerate()
     主线程 + 10个子线程
    (lst,len(lst))

     3.activeCount() 返回目前正在运行的线程数量
    print(activeCount())   11

 func1():
    while True:
        time.sleep(0.5我是func1 func2():
    我是func2 start ... )
    time.sleep(3我是func2 end ...  func3():
    我是func3 start ... )
    time.sleep(5我是func3 end ... :
    t1 = Thread(target=func1)
    t2 = Thread(target=func2)
    t3 = Thread(target=func3)
    
     在start调用之前,设置线程为守护线程
    t1.setDaemon(True)
    
    t1.start()
    t2.start()
    t3.start()
    
    主线程执行结束 .... ")

n = 0


 func1(lock):
     n
    in range(1000000):
        n += 1


 lock.release()

 func2(lock):
    ):
        n -= 1


 []
    lock = Lock()

    startime =):
        t1 = Thread(target=func1,1)">(lock,))
        t2 = Thread(target=func2,))
        t1.start()
        t2.start()
        lst.append(t1)
        lst.append(t2)

     lst:
        i.join()

    endtime =主线程执行结束 ...  打印{} 时间是{}".format(n,endtime - startime))

 func(i,sm):
     上锁 + 解锁
    with sm:
        (i)
        time.sleep(3)    
 支持同一时间,5个线程上锁
    sm = Semaphore(5in range(20):
        Thread(target=func,sm)).start()
    
"""
再创建线程的时候是异步创建
在执行任务时,遇到Semaphore进行上锁,会变成同步程序
"""

lock = Lock()
lock.acquire()
lock.acquire()
lock.acquire()  只上锁不解锁，会产生死锁。运行程序会发生阻塞

lock.release()
print(1)

noodle_lock = Lock()
kuaizi_lock = Lock()


 eat1(name):
    noodle_lock.acquire()
    %s 抢到面条了" % (name))
    kuaizi_lock.acquire()
    %s 抢到筷子了 (name))

    开始享受面条 ... )
    time.sleep(0.5)

    kuaizi_lock.release()
    %s 放下筷子 (name))
    noodle_lock.release()
    %s 放下面条 (name))


 eat2(name):
    kuaizi_lock.acquire()
     (name))
    noodle_lock.acquire()
    )

    noodle_lock.release()
     (name))
    kuaizi_lock.release()
    :
    name_lst1 = [FlyHurt]
    name_lst2 = [AlanCat]

    for name  name_lst1:
        Thread(target=eat1,1)">(name,)).start()

     name_lst2:
        Thread(target=eat2,args=(name,)).start()

from threading import RLock

rlock = RLock()
rlock.acquire()
rlock.acquire()
rlock.acquire()
rlock.acquire()
print(112233)
rlock.release()
rlock.release()
rlock.release()
rlock.release()

程序结束 ... ")

noodle_lock = kuaizi_lock = RLock()

 (name))


5.用互斥锁解决2中(面条-筷子)的死锁现象
用互斥锁解决问题，换句话来说，就是尽量用一把锁解决问题

mylock = Lock()
 eat1(name):
    mylock.acquire()
     (name))
     (name))
    
    )    

     (name))
    mylock.release()

 eat2(name):
    mylock.acquire()
     (name))    
    :
    
    name_lst1 = [ABCD]
    
    


事件:Event
e = Event()
wait 动态添加阻塞
clear 将内部的阻塞值改成False
set 将内部的阻塞值改成True
is_set 获取内部的阻塞值状态(True False)
基本语法

e = Event()
(e.is_set())
e.set()
(e.is_set())
e.clear()
(e.is_set())
 代表最多阻塞3秒
e.wait(3)
程序运行中... ")

模拟链接远程数据库

 check(e):
     用一些延迟来模拟检测的过程
    time.sleep(random.randrange(1,6))  1 2 3 4 5
     time.sleep(1)
    开始检测链接用户的合法性)
    e.set()
    
    
 connect(e):
    sign = False
    in range(1,4):  1 2 3    
         设置最大等待1秒
        e.wait(1)    
    
        if e.is_set():
            数据库链接成功 ... )
            sign = True
            break
        else:
            尝试链接数据库第%s次失败 ...  (i))
            
    if sign == False:
         主动抛出异常,(超时异常)
        raise TimeoutError
        
e = 线程1号负责执行连接任务
Thread(target=connect,1)">(e,)).start()

 线程2号负责执行检测任务
Thread(target=check,args=(e,)).start()

运行结果如下图所示
                        
（编辑：李大同）
【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!