Python threading中lock的使用详解

在多线程中使用lock可以让多个线程在共享资源的时候不会“乱”，例如，创建多个线程，每个线程都往空列表l中添加一个数字并打印当前的列表l，如果不加锁，就可能会这样：

# encoding=utf8
import threading
import time
lock = threading.Lock()
l = []

def test1(n):
	lock.acquire()
	l.append(n)
	print l
	lock.release()

def test(n):
	l.append(n)
	print l

def main():
	for i in xrange(0, 10):
		th = threading.Thread(target=test, args=(i, ))
		th.start()
if __name__ == '__main__':
	main()

运行结果：

[0]
[0, 1]
[0, 1, 2]
[0, 1, 2, 3][
0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4[, 05, , 16, , 27, ]3
, 4, 5, 6[, 07, , 18, ]2
, 3, 4, [50, , 61, , 72, , 83, , 94], 
5, 6, 7, 8, 9]

因为每个线程都在同时往l中添加一个数字（当前每个线程运行的是test函数），然后又可能在同时打印l，所以最后的结果看起来会有些“混乱”。

下面让每个线程调用“test1”函数，看看结果如何：

[0]
[0, 1]
[0, 1, 2]
[0, 1, 2, 3]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7, 8]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

现在看起来就好多了，因为test1中每次像l中添加数字并打印之前，都先加了一把“锁”，这样就可以保证每次只有一个线程可以往l中添加数字，而不是同时往l里添加数字。

通过上面的结果比较可以知道，当多线程中需要“独占资源”的时候，要使用锁来控制，防止多个线程同时占用资源而出现其他异常。

使用锁的时候就调用acquire()方法，以此告诉其他线程，我正在占用该资源，你们要等会；待使用资源后需要释放资源的时候就调用release()方法，告诉其他线程，我已经完成使用该资源了，其他人可以过来使用了。

python threading Lock

这篇文章主要是通过代码说明：

  • threading.Lock()不影响 multiprocessing
  • .threading.Lock()影响 threading.

代码如下：

import threading
import time
from multiprocessing import Pool
_lock = threading.Lock()
def small_func(value):
    """
    添加线程锁
    :param value:
    :return:
    """
    print(value)
    with _lock:
        time.sleep(5)
    return value
def no_small_func(value):
    """
    没有线程锁
    :param value:
    :return:
    """
    print(value)
    # with _lock:
    time.sleep(5)
    return value
def main():
    """
    multiprocessing 是基于进程的，因此线程锁对其不影响，
    :return:
    """
    st = time.time()
    p = Pool(processes=4)
    value = p.map(func=small_func, iterable=range(4))
    et = time.time()
    print(f"all use time: {et - st}")
    print(value)
def main2():
    """
    threading 受到 线程锁 影响
    :return:
    """
    st = time.time()
    thread_list = []
    for temp_value in range(4):
        t = threading.Thread(target=small_func, args=(temp_value,))
        t.start()
        thread_list.append(t)

    for i in thread_list:
        i.join()

    et = time.time()
    print(f"all use time: {et - st}")
    # print(value)
def main3():
    st = time.time()
    thread_list = []
    res = []
    for temp_value in range(4):
        # 不加线程锁就行了
        t = threading.Thread(target=no_small_func, args=(temp_value,))
        t.start()
        thread_list.append(t)

    for i in thread_list:
        v = i.join()
        res.append(v)

    et = time.time()
    print(f"all use time: {et - st}")
    print(res)
if __name__ == '__main__':
    # main()
    # main2()
    main3()

到此这篇关于Python threading中lock的使用的文章就介绍到这了,更多相关Python threading lock使用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

赞 (0)

相关推荐

  • 对python多线程中互斥锁Threading.Lock的简单应用详解

    一.线程共享进程资源 每个线程互相独立,相互之间没有任何关系,但是在同一个进程中的资源,线程是共享的,如果不进行资源的合理分配,对数据造成破坏,使得线程运行的结果不可预期.这种现象称为"线程不安全". 实例如下: #-*- coding: utf-8 -*- import threading import time def test_xc(): f = open("test.txt","a") f.write("test_dxc&quo

  • python多线程threading.Lock锁用法实例

    本文实例讲述了python多线程threading.Lock锁的用法实例,分享给大家供大家参考.具体分析如下: python的锁可以独立提取出来 复制代码 代码如下: mutex = threading.Lock() #锁的使用 #创建锁 mutex = threading.Lock() #锁定 mutex.acquire([timeout]) #释放 mutex.release() 锁定方法acquire可以有一个超时时间的可选参数timeout.如果设定了timeout,则在超时后通过返回值

  • Python threading模块中lock与Rlock的使用详细讲解

    目录 前言 1.Lock(互斥锁) 2.RLock(可重入锁) 前言 在使用多线程的应用下,如何保证线程安全,以及线程之间的同步,或者访问共享变量等问题是十分棘手的问题,也是使用多线程下面临的问题,如果处理不好,会带来较严重的后果,使用python多线程中提供Lock .Rlock .Semaphore .Event .Condition 用来保证线程之间的同步,后者保证访问共享变量的互斥问题. Lock & RLock:互斥锁,用来保证多线程访问共享变量的问题 Semaphore对象:Lock

  • python中的多线程锁lock=threading.Lock()使用方式

    目录 多线程锁lock=threading.Lock()使用 疑问 解决方法 例子 python多线程中锁的概念 锁可以独立提取出来 概念 线程不安全 线程锁 多线程锁lock=threading.Lock()使用 疑问 多线程任务是同时执行的,如果我们需要先执行线程a,再执行线程b,需要怎么办呢? 解决方法 使用python的多线程锁lock. 例子 未使用多线程锁lock: def a():     for i in range(3):         print('a%d' % (i +

  • Python threading中lock的使用详解

    在多线程中使用lock可以让多个线程在共享资源的时候不会“乱”,例如,创建多个线程,每个线程都往空列表l中添加一个数字并打印当前的列表l,如果不加锁,就可能会这样: # encoding=utf8 import threading import time lock = threading.Lock() l = [] def test1(n): lock.acquire() l.append(n) print l lock.release() def test(n): l.append(n) pr

  • python爬虫中多线程的使用详解

    queue介绍 queue是python的标准库,俗称队列.可以直接import引用,在python2.x中,模块名为Queue.python3直接queue即可 在python中,多个线程之间的数据是共享的,多个线程进行数据交换的时候,不能够保证数据的安全性和一致性,所以当多个线程需要进行数据交换的时候,队列就出现了,队列可以完美解决线程间的数据交换,保证线程间数据的安全性和一致性. #多线程实战栗子(糗百) #用一个队列Queue对象, #先产生所有url,put进队列: #开启多线程,把q

  • Python threading Local()函数用法案例详解

    Python threading Local()函数用法案例详解

    目录 前言 local() 函数是什么? local()函数如何用? 1. 不做标记,不做隔离 2.使用local()函数加以控制 3. 模拟实现local()的功能,创建一个箱子 4. 简化代码操作,进一步模拟实现local()函数 总结 前言 当多线程访问同一个公共资源时,如果涉及到修改该公共资源的操作就可能会出现由于数据不同步导致的线程安全问题.一般情况下我们可以通过给公共资源加互斥锁的方式来处理该问题. 当然,除非必须将多线程使用的资源设置为公共资源的情况.如果一个资源不需要在多个线程之

  • python flask中动态URL规则详解

    URL是可以添加变量部分的, 把类似的部分抽象出来, 比如: @app.route('/example/1/') @app.route('/example/2/') @app.route('/example/3/') def example(id): return 'example:{ }'.format(id) 可以抽象为: @app.route('/example/<id>/') def wxample(id): return 'example:{ }'.format(id) 尖括号中的内

  • Python字典中items()函数案例详解

    Python3:字典中的items()函数 一.Python2.x中items():   和之前一样,本渣渣先贴出来python中help的帮助信息: >>> help(dict.items) Help on method_descriptor: items(...) D.items() -> list of D's (key, value) pairs, as 2-tuples >>> help(dict.iteritems) Help on method_de

  • Python类中self参数用法详解

    Python编写类的时候,每个函数参数第一个参数都是self,一开始我不管它到底是干嘛的,只知道必须要写上.后来对Python渐渐熟悉了一点,再回头看self的概念,似乎有点弄明白了. 首先明确的是self只有在类的方法中才会有,独立的函数或方法是不必带有self的.self在定义类的方法时是必须有的,虽然在调用时不必传入相应的参数. self名称不是必须的,在python中self不是关键词,你可以定义成a或b或其它名字都可以,但是约定成俗(为了和其他编程语言统一,减少理解难度),不要搞另类,

  • Python Pygame中精灵和碰撞检测详解

    Pygame精灵和碰撞检测 今天来看看python最出名的游戏库pygame.学习两个名词:精灵和碰撞检测. 精灵英文字母是Sprite.Sprite是二维的图形,在游戏中可以用做各种物品,例如人物,道具,反正所有一切展现在游戏图像中的都可以用Sprite. 而碰撞检测就是检测两个Sprite之间是否有碰撞.例如游戏中的吃金币,吃豆豆,打敌人都可以用到碰撞检测. class Sprite(pygame.sprite.Sprite): def __init__(self, pos): pygame

  • python基础中的文件对象详解

    python基础中的文件对象详解

    目录 一.python读取和写入文件内容 二.文件对象的写入 三.实现文件内容的拷贝 四.通过文件对象cmd.exe对命令行工具进行复制 总结 一.python读取和写入文件内容 任务:在cmd默认登陆目录中建立一个命名为test.txt的文件并写入内容“welcome python” 打开文件的三个步骤 1.建立文件对象-打开冰箱门 2.读取文件-把大象拿出来 f = open("C:\\Users\\Administrator\\test.txt","rb")#

  • Python函数中的作用域规则详解

    目录 1.简单介绍一下闭包 2.在Python中,并不是任何代码块都能引入新的作用域 3.在Python中,名字绑定在所属作用域中引入新的变量,同时绑定到一个对象. 总结 Python是静态作用域语言,但是它自身是一个动态语言.在Python中变量的作用域是由变量在代码中的位置决定的,与C语言有些相似,但不是完全一样. 在Python 2.0及之前的版本中,Python只支持3种作用域,即局部作用域,全局作用域,内置作用域:在Python2.2中,Python正式引入了一种新的作用域 — 嵌套作

  • python numpy中cumsum的用法详解

    Cumsum :计算轴向元素累加和,返回由中间结果组成的数组 重点就是返回值是"由中间结果组成的数组" 以下代码在python3.6版本运行成功! 下面看代码,定义一个2*2*3的数组,所以其shape是2,2,3,索引分别0,1,2 shape 索引 2 0 2 1 3 2 代码: import numpy as np arr = np.array([[[1,2,3],[8,9,12]],[[1,2,4],[2,4,5]]]) #2*2*3 print(arr.cumsum(0))

随机推荐