线程--守护线程、线程锁、信号量、事件、条件、定时器、队列、池(三)

守护线程

import timefrom threading import Threaddef func1():    while True:        print(‘*‘*10)        time.sleep(1)def func2():    print(‘in func2‘)    time.sleep(5)

t = Thread(target=func1,)t.daemon = Truet.start()t2 = Thread(target=func2,)t2.start()t2.join() #加join后会等待func2结束后在打印print(‘主线程‘)

# 守护进程随着主进程代码的执行结束而结束
# 守护线程会在主线程结束之后等待其他子线程的结束才结束

# 主进程在执行完自己的代码之后不会立即结束 而是等待子进程结束之后 回收子进程的资源# import time# from multiprocessing import Process# def func():#     time.sleep(5)## if __name__ == ‘__main__‘:#         Process(target=func).start()

线程锁

为什么Cpython自带GIL锁还出现死锁,因为是对线程GIL锁,避免不了时间片轮转带来数据不安全

import timefrom threading import Lock,Thread# Lock 互斥锁(只有一个钥匙)
# def func(lock):#     global n#     lock.acquire()#     temp = n#     time.sleep(0.2)#     n = temp - 1#     lock.release()## n = 10# t_lst = []# lock = Lock()# for i in range(10):#     t = Thread(target=func,args=(lock,))#     t.start()#     t_lst.append(t)

# for t in  t_lst: t.join()# print(n)

# 科学家吃面

# noodle_lock  = Lock()# fork_lock = Lock()# def eat1(name):#     noodle_lock.acquire()#     print(‘%s拿到面条啦‘%name)#     fork_lock.acquire()#     print(‘%s拿到叉子了‘%name)#     print(‘%s吃面‘%name)#     fork_lock.release()#     noodle_lock.release()## def eat2(name):#     fork_lock.acquire()#     print(‘%s拿到叉子了‘%name)#     time.sleep(1)#     noodle_lock.acquire()#     print(‘%s拿到面条啦‘%name)#     print(‘%s吃面‘%name)#     noodle_lock.release()#     fork_lock.release()## Thread(target=eat1,args=(‘alex‘,)).start()  # Thread(target=eat2,args=(‘Egon‘,)).start()# Thread(target=eat1,args=(‘bossjin‘,)).start()# Thread(target=eat2,args=(‘nezha‘,)).start()执行上面代码后出现死锁阻塞

解决死锁问题

from threading import RLock   # 递归锁(一串钥匙,多少根据accquire多少次)
fork_lock = noodle_lock  = RLock()   # 一个钥匙串上的两把钥匙def eat1(name):    noodle_lock.acquire()            # 一把钥匙    print(‘%s拿到面条啦‘%name)    fork_lock.acquire()    print(‘%s拿到叉子了‘%name)    print(‘%s吃面‘%name)    fork_lock.release()    noodle_lock.release()

def eat2(name):    fork_lock.acquire()    print(‘%s拿到叉子了‘%name)    time.sleep(1)    noodle_lock.acquire()    print(‘%s拿到面条啦‘%name)    print(‘%s吃面‘%name)    noodle_lock.release()    fork_lock.release()

Thread(target=eat1,args=(‘alex‘,)).start()Thread(target=eat2,args=(‘Egon‘,)).start()Thread(target=eat1,args=(‘bossjin‘,)).start()Thread(target=eat2,args=(‘nezha‘,)).start()

原文地址:https://www.cnblogs.com/mys6/p/10886510.html

时间: 2024-08-08 06:43:42

线程--守护线程、线程锁、信号量、事件、条件、定时器、队列、池(三)的相关文章

python开发线程:死锁和递归锁&信号量&定时器&线程queue&事件evevt

一 死锁现象与递归锁 进程也有死锁与递归锁,在进程那里忘记说了,放到这里一切说了额 所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁 from threading import Thread,Lock import time mutexA=Lock() mutexB=Lock() class MyThread(Thread):

线程高级篇-Lock锁和Condition条件

浅谈Synchronized: synchronized是Java的一个关键字,也就是Java语言内置的特性,如果一个代码块被synchronized修饰了,当一个线程获取了对应的锁,执行代码块时,其他线程 便只能一直等待,等待获取锁的线程释放锁,而获取锁的线程释放锁会有三种情况: 1).获取锁的线程执行完该代码块,然后线程释放对锁的占有; 2).线程执行发生异常,此时JVM会让线程自动释放锁; 3).调用wait方法,在等待的时候立即释放锁,方便其他的线程使用锁. Lock的特性: 1).Lo

041.Python守护进程,锁信号量和事件

一 守护进程 1.1 基本概念 守护进程 正常情况下,主进程默认等待子进程调用结束之后结束 守护进程在主进程执行代码结束后,自动终止 守护进程语法: 进程对象.daemon = True ,设置该进程是守护进程 守护进程需要在start()方法之前设置 为主进程守护,主进程如果代码执行结束了,该守护进程自动结束. 1.2 基本语法 import os import time from multiprocessing import Process def func(): print("子进程sta

python 并发编程 锁 / 信号量 / 事件 / 队列(进程间通信(IPC)) /生产者消费者模式

(1)锁:进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,而共享带来的是竞争,竞争带来的结果就是错乱,如何控制,就是加锁处理. 虽然使用加锁的形式实现了顺序的执行,但是程序又重新变成串行了,这样确实会浪费了时间,却保证了数据的安全. (Lock) import json from multiprocessing import Process,Lock ###### 锁 ###### import time import random def get

java线程内存模型,线程、工作内存、主内存

转自:http://rainyear.iteye.com/blog/1734311 java线程内存模型 线程.工作内存.主内存三者之间的交互关系图: key edeas 所有线程共享主内存 每个线程有自己的工作内存 refreshing local memory to/from main memory must  comply to JMM rules 产生线程安全的原因 线程的working memory是cpu的寄存器和高速缓存的抽象描述:现在的计算机,cpu在计算的时候,并不总是从内存读

13 join 线程锁之Lock\Rlock\信号量 将线程变为守护进程 Event事件  queue队列 生产者消费者模型 Queue队列 开发一个线程池

本节内容 操作系统发展史介绍 进程.与线程区别 python GIL全局解释器锁 线程 语法 join 线程锁之Lock\Rlock\信号量 将线程变为守护进程 Event事件 queue队列 生产者消费者模型 Queue队列 开发一个线程池 进程 语法 进程间通讯 进程池 操作系统发展史 手工操作(无操作系统) 1946年第一台计算机诞生--20世纪50年代中期,还未出现操作系统,计算机工作采用手工操作方式. 手工操作程序员将对应于程序和数据的已穿孔的纸带(或卡片)装入输入机,然后启动输入机把

死锁现象与解决方案,开启线程的2种方式,守护线程,线程VS进程,线程互斥锁,信号量

死锁现象与解决方案 from threading import Thread,Lock,active_count import time mutexA=Lock() # 锁1 mutexB=Lock() # 锁2 class Mythread(Thread): def run(self): self.f1() self.f2() def f1(self): mutexA.acquire() print('%s 拿到A锁' %self.name) mutexB.acquire() print('%

Python36 1.joinablequeue 2.线程理论 3.多线程对比多进程 4.线程的使用方式 4.1.产生 线程的两种方式 4.2.守护线程 4.3.线程安全问题 4.3.1.互斥锁 4.3.2.死锁 4.3.3.可重入锁 4.3.4.信号量

复习1.守护进程2.互斥锁(解决数据错乱的方法)3.IPC(进程间通讯)4.生产者与消费者模型 详解:1.守护进程 一个进程可以设为另一个进程的守护进程 特点:被守护的进程结束时,守护进程也会随之结束 本质:父进程交给子进程一个任务,然而父进程 先于子进程结束了,子进程的任务也就没有必要 继续执行了 格式:开始前加 p.daemon=True 2.互斥锁(解决数据错乱的方法)方法一:互斥锁 互斥 互相排斥 锁的本质:一个标志 标志的两个状态: 1.锁定 2.未锁定 什么时候用? 当多个进程要操作

36 线程 队列 守护线程 互斥锁 死锁 可重入锁 信号量

线程 线程是操作系统最小的运算调度单位,被包含在进程中,一个线程就是一个固定的 执行流程 线程和进程的关系 线程不能单独存在 必须存在于进程中, 进程是一个资源单位,其包含了运行程序所需的所有资源 线程才是真正的执行单位 没有线程,进程中的资源无法被利用起来,所以一个进程至少包含一个线程,称之为主线程 当我们启动一个程序时,操作系统就会自己为这个程序创建一个主线程 线程可以由程序后期开启 ,自己开启线程称之为子线程 为什么需要线程 目的只有一个就是提高效率 就像一个车间 如果产量跟不上 就再造一