Python的互斥锁与信号量详解

并发与锁

多个线程共享数据的时候,如果数据不进行保护,那么可能出现数据不一致现象,使用锁,信号量、条件锁

互斥锁

1. 互斥锁,是使用一把锁把代码保护起来,以牺牲性能换取代码的安全性,那么Rlock后 必须要relase 解锁 不然将会失去多线程程序的优势

2. 互斥锁的基本使用规则:

import threading
# 声明互斥锁
lock=threading.Rlock();
def handle(sid):# 功能实现代码
lock.acquire() #加锁
# writer codeing
lock.relase() #释放锁

信号量:

1. 调用relarse()信号量会+1 调用 acquire() 信号量会-1

可以理解为对于临界资源的使用,以及进入临界区的判断条件

2. semphore() :当调用relarse()函数的时候 单纯+1 不会检查信号量的上限情况。 初始参数为0

3. boudedsemphore():边界信号量 当调用relarse() 会+1 , 并且会检查信号量的上限情况。不允许超过上限

使用budedsemaphore时候不允许设置初始为0,将会抛出异常

至少设置为1 ,如consumer product 时候应该在外设置一个变量,启动时候对变量做判断,决定使不使用acquier

4. 信号量的基本使用代码:

# 声明信号量:
sema=threading.Semaphore(0); #无上限检查
sema=threading.BuderedSeamphore(1) #有上限检查设置
5
apple=1
def consumner():
seam.acquire(); # ‐1
9
if apple==1:
pass
else: sema2.release();#+ 1
def product():
seam.relarse(); # +1
if apple==1:
pass
else:
print("消费:",apple);

全部的代码:

# -*- coding: utf-8 -*-
"""
Created on Mon Sep 9 21:49:30 2019

@author: DGW-PC
"""
# 信号量解决生产者消费者问题
import random;
import threading;
import time;

# 声明信号量
sema=threading.Semaphore(0);# 必须写参数 0 表示可以使用数
sema2=threading.BoundedSemaphore(1);

apple=1;

def product():#生产者
  global apple;
  apple=random.randint(1,100);
  time.sleep(3);
  print("生成苹果:",apple);
  #sema2.release(); # +1
  if apple==1:
     pass
  else: sema2.release();#+ 1 

def consumer():
  print("等待");
  sema2.acquire();# -1
  if apple==1:
    pass
  else:
    print("消费:",apple);
threads=[];

for i in range(1,3):
  t1=threading.Thread(target=consumer);
  t2=threading.Thread(target=product);
  t1.start();
  t2.start();
  threads.append(t1);
  threads.append(t2);
for x in threads:
  x.join();

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

时间: 2019-09-11

Python多线程编程(四):使用Lock互斥锁

前面已经演示了Python:使用threading模块实现多线程编程二两种方式起线程和Python:使用threading模块实现多线程编程三threading.Thread类的重要函数,这两篇文章的示例都是演示了互不相干的独立线程,现在我们考虑这样一个问题:假设各个线程需要访问同一公共资源,我们的代码该怎么写? 复制代码 代码如下: ''' Created on 2012-9-8   @author: walfred @module: thread.ThreadTest3 '''  impor

Python实现正弦信号的时域波形和频谱图示例【基于matplotlib】

本文实例讲述了Python实现正弦信号的时域波形和频谱图.分享给大家供大家参考,具体如下: # -*- coding: utf-8 -*- # 正弦信号的时域波形与频谱图 import numpy as np import matplotlib.pyplot as pl import matplotlib import math import random row = 4 col = 4 N = 500 fs = 5 n = [2*math.pi*fs*t/N for t in range(N)

举例讲解Python中的死锁、可重入锁和互斥锁

一.死锁 简单来说,死锁是一个资源被多次调用,而多次调用方都未能释放该资源就会造成死锁,这里结合例子说明下两种常见的死锁情况. 1.迭代死锁 该情况是一个线程"迭代"请求同一个资源,直接就会造成死锁: import threading import time class MyThread(threading.Thread): def run(self): global num time.sleep(1) if mutex.acquire(1): num = num+1 msg = se

python互斥锁、加锁、同步机制、异步通信知识总结

某个线程要共享数据时,先将其锁定,此时资源的状态为"锁定",其他线程不能更改:直到该线程释放资源,将资源的状态变成"非锁定",其他的线程才能再次锁定该资源.互斥锁保证了每次只有一个线程进入写入操作,从而保证了多线程情况下数据的正确性. 采用f_flag的方法效率低 创建锁 mutex=threading.Lock() 锁定 mutex.acquire([blocking])#里面可以加blocking(等待的时间)或者不加,不加就会一直等待(堵塞) 释放 mutex

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

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

Python实现的多线程同步与互斥锁功能示例

本文实例讲述了Python实现的多线程同步与互斥锁功能.分享给大家供大家参考,具体如下: #! /usr/bin/env python #coding=utf-8 import threading import time ''' #1.不加锁 num = 0 class MyThread(threading.Thread): def run(self): global num time.sleep(1) #一定要sleep!!! num = num + 1 msg = self.name + '

Java使用synchronized实现互斥锁功能示例

本文实例讲述了Java使用synchronized实现互斥锁功能.分享给大家供大家参考,具体如下: 代码 package per.thread; import java.io.IOException; public class Test { private int i = 0; private Object object = new Object(); public static void main(String[] args) throws IOException { Test test =

Python多线程操作之互斥锁、递归锁、信号量、事件实例详解

本文实例讲述了Python多线程操作之互斥锁.递归锁.信号量.事件.分享给大家供大家参考,具体如下: 互斥锁: 为什么要有互斥锁:由于多线程是并行的,如果某一线程取出了某一个数据将要进行操作,但它还没有那么快执行完操作,这时候如果另外一个线程也要操作这个数据,那么这个数据可能会因为两次操作而发生错误 import time,threading x=6 def run1(): print("run1我拿到了数据:",x) print("我现在还不想操作,先睡一下")

python 获取键盘输入,同时有超时的功能示例

如下所示: ''' ###get keyboard input and timeout =5 import sys, time, msvcrt def readInput( caption, default, timeout = 5): start_time = time.time() sys.stdout.write('%s(%s):'%(caption, default)); input = '' while True: if msvcrt.kbhit(): chr = msvcrt.get

Java多线程并发编程(互斥锁Reentrant Lock)

Java 中的锁通常分为两种: 通过关键字 synchronized 获取的锁,我们称为同步锁,上一篇有介绍到:Java 多线程并发编程 Synchronized 关键字. java.util.concurrent(JUC)包里的锁,如通过继承接口 Lock 而实现的 ReentrantLock(互斥锁),继承 ReadWriteLock 实现的 ReentrantReadWriteLock(读写锁). 本篇主要介绍 ReentrantLock(互斥锁). ReentrantLock(互斥锁)

详解Java多线程编程中互斥锁ReentrantLock类的用法

0.关于互斥锁 所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前, 我们通常使用synchronized机制控制多个线程对共享资源的访问. 而现在, Lock提供了比synchronized机制更广泛的锁定操作, Lock和synchronized机制的主要区别: synchronized机制提供了对与每个对象相关的隐式监视器锁的访问, 并强制所有锁获取和释放均要出现在一个块结构中, 当获取了多个锁时, 它们必须以相反的顺序释放. synchronized机制对锁的释放是

Python网络编程基于多线程实现多用户全双工聊天功能示例

本文实例讲述了Python网络编程基于多线程实现多用户全双工聊天功能.分享给大家供大家参考,具体如下: 在前面一篇<Python网络编程使用select实现socket全双工异步通信功能>中,我们实现了1对1的异步通信,在文章结尾,给出了多对多通信的思路. 既然说了,咱就动手试一试,本次用的是多线程来实现,正好练练手- 首先讲一下思路: 我们将服务器做为中转站来处理信息,一方面与客户端互动,另一方面进行消息转发. 大体思路确定下来后,需要确定一些通信规则: 1. 客户端与服务器建立连接后,需要

Python实现的redis分布式锁功能示例

本文实例讲述了Python实现的redis分布式锁功能.分享给大家供大家参考,具体如下: #!/usr/bin/env python # coding=utf-8 import time import redis class RedisLock(object): def __init__(self, key): self.rdcon = redis.Redis(host='', port=6379, password="", db=1) self._lock = 0 self.lock

Python基于socket实现简单的即时通讯功能示例

本文实例讲述了Python基于socket实现简单的即时通讯功能.分享给大家供大家参考,具体如下: 客户端tcpclient.py # -*- coding: utf-8 -*- import socket import threading # 目标地址IP/URL及端口 target_host = "127.0.0.1" target_port = 9999 # 创建一个socket对象 client = socket.socket(socket.AF_INET,socket.SOC

Python实现的FTP通信客户端与服务器端功能示例

本文实例讲述了Python实现的FTP通信客户端与服务器端功能.分享给大家供大家参考,具体如下: 一 代码 1.服务端代码 import socket import threading import os import struct #用户账号.密码.主目录 #也可以把这些信息存放到数据库中 users = {'zhangsan':{'pwd':'zhangsan1234', 'home':r'c:\python 3.5'}, 'lisi':{'pwd':'lisi567', 'home':'c