python 线程(创建2种方式,守护进程,锁,死锁,递归锁,GIL锁,其他方式)

###############总结############

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

进程:资源分配单位    线程:cpu执行单位(实体)

线程的创建和销毁的开销特别小

线程之间资源共享,是同一个进程中的资源共享,会涉及到安全问题,所以需要加锁解决

:牺牲了效率,保证了数据安全(重点)

死锁现象:出现在嵌套的时候,双方互相抢对方已经拿到的锁,导致双方互相等待(重点)

递归锁: 解决了死锁现象(重点)

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

守护线程:

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

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

GIL锁:

###第一种from threading import Thread
def f1(n):
    print(n)
if __name__ == ‘__main__‘:
    t1=Thread(target=f1,args=(1,))
    t1.start()
###第二种
class mythread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print(‘hellow‘+self.name)
if __name__ == ‘__main__‘:
    t=mythread(‘alex‘)
    t.start()
    print(‘主线程结束‘)

###查看线程的进程id

import os
from  threading import Thread
def f1(n):
    print(‘1号‘,os.getpid())
    print(‘%s号‘%n)
def f2(n):
    print(‘2号‘,os.getpid())
    print(‘%s‘%n)
if __name__ == ‘__main__‘:
    t1=Thread(target=f1,args=(1,))
    t2=Thread(target=f2,args=(2,))
    t1.start()
    t2.start()
    print(‘主进程id‘,os.getpid())
############
线程ID是一样的

###验证线程是数据共享的

import os
import time
from threading import Thread
num=100
def f1(n):
    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

###多进程效率对比

import time
from threading import Thread
from multiprocessing import Process
def f1():
    for i in range(5):
        i=i+i
if __name__ == ‘__main__‘:
    t_s_time=time.time()
    t_list=[]
    # 查看一下20个线程执行20个任务的执行时间
    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
    # print(t_dif_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 for pp in p_list]
    p_e_time=time.time()
    p_dif_time=p_e_time-p_s_time
    print(‘线程执行的时间%s‘%t_dif_time)
    print(‘进程执行的时间%s‘ % p_dif_time)
###################
线程执行的时间0.003000497817993164
进程执行的时间0.2560145854949951

####锁

import time
from multiprocessing import Process
from threading import Thread,Lock
num=100
def f1(loc):
    loc.acquire()
    global num
    tmp=num
    tmp-=1
    time.sleep(0.01)#模拟
    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)
##############
主进程 90

#####死锁现象

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()
##################
f1>>1号抢到了A锁
f2>>2号抢到了B锁

原文地址:https://www.cnblogs.com/zaizai1573/p/10257718.html

时间: 2024-11-07 23:21:36

python 线程(创建2种方式,守护进程,锁,死锁,递归锁,GIL锁,其他方式)的相关文章

并发编程8 线程的创建&验证线程之间数据共享&守护线程&线程进程效率对比&锁(死锁/递归锁)

1.线程理论以及线程的两种创建方法 2.线程之间是数据共享的与join方法 3.多线程和多进程的效率对比 4.数据共享的补充线程开启太快 5.线程锁 互斥锁 同步锁 6.死锁现象和递归锁 7.守护线程和守护进程的对比 8.补充 9.GIL锁&GIL锁与线程锁的区别 10.GIL锁补充 11.信号量 时间补充说明 原文地址:https://www.cnblogs.com/studybrother/p/10269278.html

线程的创建 验证线程之间共享数据 守护线程 线程进程效率对比 锁 死锁 递归锁

线程(from threading import Thread):CPU调度的最小单位 线程的两种创建方式:方式一: 1 from threading import Thread 2 def f1(i): 3 print(i) 4 if __name__ == '__main__': 5 for i in range(10): 6 t = Thread(target=f1,args=(i,)) 7 t.start() 8 print('主线程') 方式二: 1 from threading im

php两种实现守护进程的方式

第一种方式,借助 nohup 和 &  配合使用. 在命令后面加上 & 符号, 可以让启动的进程转到后台运行,而不占用控制台,控制台还可以再运行其他命令,这里我使用一个while死循环来做演示,代码如下 <?php while(true){ echo time().PHP_EOL; sleep(3);} 用 & 方式来启动该进程[[email protected] php]# php deadloop.php &[1] 3454[[email protected] p

锁和多线程:线程创建3种方式(一)

线程 锁Synchronized 1.线程创建 2.线程安全 搞明白 线程 锁和多线程系列 1.线程创建 线程创建常见的三种方式: 继承Thread类 实现Runnable接口 实现Callable接口 第三种方式有异步调用效果,类似js中的ajax可以接收返回值,其余两种不能. package thread; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import

创建一个简单的守护进程

1.概念 守护进程也称精灵进程,是在后台运行的一种特殊进程,它脱离控制终端并且周期性的执行某种任务或者等待某种事件的发生,脱离终端是为了避免进程在执行过程中的信息在任何终端上显示,并且进程也不会被任何终端产生的中断信息所终止:linux下的大多 服务器都是用守护进程实现的.比如internet 的inted 和wed 服务器httpd 2.创建守护进程的一般步骤 (1)调用umask重设文件权限掩码 文件权限掩码:指屏蔽掉文件权限中的对应位.例如,有个文件权限掩码为050,它就屏蔽掉了文件组拥有

java中线程分两种,守护线程和用户线程。

java中线程分为两种类型:用户线程和守护线程. 通过Thread.setDaemon(false)设置为用户线程: 通过Thread.setDaemon(true)设置为守护线程. 如果不设置次属性,默认为用户线程. 区别:主线程结束后用户线程会继续运行,JVM存活:主线程结束后,如果没有用户线程,都是守护线程,则JVM结束. public class Mytest extends Thread { public void run() { for(int i=0;;i++){ try { Th

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

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

线程池Python 线程、进程和协程

Python   线程 Threading是用于提供线程相关的操作,线程是应用程序中工作的最小单元.线程与进程的关系下图所示: 子线程是由主线程产生的,但两者并没有关联. 利用threading创建线程: 1 '''利用threading包创建''' 2 import threading 3 import time 4 5 def run(n): 6 time.sleep(2) 7 print("task:",n) 8 9 '''串行:一个运行完后,再运行另外一个''' 10 run(

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

什么是线程 进程:资源分配单位 线程: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