注册会员 | 设为首页 | 加入收藏夹
您好，欢迎光临本网站！[请登录] ！[注册会员]！  

搜索资源列表

  1. Linux下多线程编程的互斥与同步

  2. 本文将说明如何使用信号量实现线程之间的互斥与同步。互斥锁只有0，1两中状态，适合于线程对共享资源的独占访问，很多时候每个资源可以同时被有限的线程访问，此时互斥锁将无法满足；条件变量同步也同样存在这种问题。信号量实际是一种非负整型计数器，可以很好的控制线程之间资源访问，互斥锁能实现的功能，信号量同样可以。

  3. 所属分类：其它

    • 发布日期：2020-07-31
    • 文件大小：53248
    • 提供者：weixin_38502693

  1. 浅析Linux下一个简单的多线程互斥锁的例子

  2. 本篇文章是对Linux下一个简单的多线程互斥锁的例子进行了分析介绍，需要的朋友可以参考下

  3. 所属分类：其它

    • 发布日期：2020-09-15
    • 文件大小：20480
    • 提供者：weixin_38736562

  1. Python中死锁的形成示例及死锁情况的防止

  2. 由于Python中允许创建多个线程,那么互斥锁或者线程同时获取多个锁的情况就有可能发生,这里我们就来看一下Python中死锁的形成示例及死锁情况的防止:

  3. 所属分类：其它

    • 发布日期：2020-09-21
    • 文件大小：80896
    • 提供者：weixin_38531630

  1. 使用互斥锁和共享内存实现的非阻塞FIFO

  2. 使用互斥锁和共享内存实现的非阻塞FIFO，另外代码中有包含信号量的实现。个人测试稳定，有一些注释，一起学习。如有问题，欢迎讨论。

  3. 所属分类：Linux

    • 发布日期：2020-11-05
    • 文件大小：6144
    • 提供者：qq_35378417

  1. Python使用分布式锁的代码演示示例

  2. 在计算机并发领域编程中总是会与锁打交道，锁又有很多种，互斥锁、自旋锁等等。 锁总是伴随着线程、进程这样的词汇出现，阮一峰有 一篇文章 对这些名词进行了简单易懂的解释。 我的理解是，使用线程、进程是为了实现并发从而获得性能的提升(利用多核CPU，多台服务器)，但这种并发由于调度的不确定性，很容易出乱子，为了(在一些共享资源、关键节点上)不出乱子，又需要对资源加锁，在操作这个资源时控制这种并发，将乱子消灭。 很多语言都提供了一些线程级别的锁实现以及一些相应的工具，但在进程方面就无能为力了。而一个服务

  3. 所属分类：其它

    • 发布日期：2020-12-25
    • 文件大小：359424
    • 提供者：weixin_38734361

  1. Python中死锁的形成示例及死锁情况的防止

  2. 死锁示例 搞多线程的经常会遇到死锁的问题，学习操作系统的时候会讲到死锁相关的东西，我们用Python直观的演示一下。 死锁的一个原因是互斥锁。假设银行系统中，用户a试图转账100块给用户b，与此同时用户b试图转账200块给用户a，则可能产生死锁。 2个线程互相等待对方的锁，互相占用着资源不释放。 #coding=utf-8 import time import threading class Account: def __init__(self, _id, balance, lock):

  3. 所属分类：其它

    • 发布日期：2020-12-25
    • 文件大小：83968
    • 提供者：weixin_38698403

  1. 用Python实现读写锁的示例代码

  2. 起步 Python 提供的多线程模型中并没有提供读写锁，读写锁相对于单纯的互斥锁，适用性更高，可以多个线程同时占用读模式的读写锁，但是只能一个线程占用写模式的读写锁。 通俗点说就是当没有写锁时，就可以加读锁且任意线程可以同时加；而写锁只能有一个线程，且必须在没有读锁时才能加上。 简单的实现 import threading class RWlock(object): def __init__(self): self._lock = threading.Lock() se

  3. 所属分类：其它

    • 发布日期：2020-12-25
    • 文件大小：55296
    • 提供者：weixin_38723461

  1. Python多线程编程（五）：死锁的形成

  2. 前一篇文章Python：使用threading模块实现多线程编程四[使用Lock互斥锁]我们已经开始涉及到如何使用互斥锁来保护我们的公共资源了，现在考虑下面的情况– 如果有多个公共资源，在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，这会引起什么问题？ 死锁概念 所谓死锁： 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

  3. 所属分类：其它

    • 发布日期：2020-12-25
    • 文件大小：54272
    • 提供者：weixin_38646914

  1. Python简单进程锁代码实例

  2. 先说说线程 在多线程中，为了保证共享资源的正确性，我们常常会用到线程同步技术. 将一些敏感操作变成原子操作，保证同一时刻多个线程中只有一个线程在执行这个原子操作。 我最常用的是互斥锁，也称独占锁。其次还有读写锁，信号量，条件变量等。 除此之外，我们在进程间通信时会用到信号，向某一个进程发送信号，该进程中设置信号处理函数，然后当该进程收到信号时，执行某些操作。 其实在线程中，也可以接受信号，利用这种机制，我们也可以用来实现线程同步。更多信息见 //www.jb51.net/article/6497

  3. 所属分类：其它

    • 发布日期：2020-12-24
    • 文件大小：48128
    • 提供者：weixin_38690508

  1. python线程中同步锁详解

  2. 在使用多线程的应用下，如何保证线程安全，以及线程之间的同步，或者访问共享变量等问题是十分棘手的问题，也是使用多线程下面临的问题，如果处理不好，会带来较严重的后果，使用python多线程中提供Lock Rlock Semaphore Event Condition 用来保证线程之间的同步，后者保证访问共享变量的互斥问题 Lock & RLock:互斥锁 用来保证多线程访问共享变量的问题 Semaphore对象：Lock互斥锁的加强版，可以被多个线程同时拥有，而Lock只能被某一个线程同时拥有。

  3. 所属分类：其它

    • 发布日期：2020-12-23
    • 文件大小：71680
    • 提供者：weixin_38635794

  1. python基础9_1-进程、线程、守护线程、全局解释器锁、生产者消费者模型

  2. 目录1、Python GIL(Global Interpreter Lock)2、进程(process)多进程multiprocessing进程间通讯-Queues/Pipes/Managers进程锁进程池3、线程(thread)语法join函数daemon(守护线程)线程锁之Lock(互斥锁mutex)/RLock(递归锁)/Semaphore(信号量)EventQueue生产者消费者模型4、进程和线程的关系区别 1、Python GIL(Global Interpreter Lock) 全局

  3. 所属分类：其它

    • 发布日期：2020-12-20
    • 文件大小：162816
    • 提供者：weixin_38635449

  1. c# mutex互斥量的深入解析

  2. 互斥锁（Mutex） 互斥锁是一个互斥的同步对象，意味着同一时间有且仅有一个线程可以获取它。 互斥锁可适用于一个共享资源每次只能被一个线程访问的情况  函数： //创建一个处于未获取状态的互斥锁 Public Mutex（）; //如果owned为true，互斥锁的初始状态就是被主线程所获取，否则处于未获取状态  Public Mutex（bool owned）;  如果要获取一个互斥锁。应调用互斥锁上的WaitOne()方法，该方法继承于Thread.WaitHandle类 它处于等到状态直至

  3. 所属分类：其它

    • 发布日期：2020-12-31
    • 文件大小：55296
    • 提供者：weixin_38684509

  1. 利用C++11原子量如何实现自旋锁详解

  2. 一、自旋锁 自旋锁是一种基础的同步原语，用于保障对共享数据的互斥访问。与互斥锁的相比，在获取锁失败的时候不会使得线程阻塞而是一直自旋尝试获取锁。当线程等待自旋锁的时候，CPU不能做其他事情，而是一直处于轮询忙等的状态。自旋锁主要适用于被持有时间短，线程不希望在重新调度上花过多时间的情况。实际上许多其他类型的锁在底层使用了自旋锁实现，例如多数互斥锁在试图获取锁的时候会先自旋一小段时间，然后才会休眠。如果在持锁时间很长的场景下使用自旋锁，则会导致CPU在这个线程的时间片用尽之前一直消耗在无意义的忙

  3. 所属分类：其它

    • 发布日期：2020-12-26
    • 文件大小：96256
    • 提供者：weixin_38538224

  1. 性能测试中的吞吐量和延迟、信号量和互斥锁

  2. 我们知道，计算机中有很多概念并不容易理解，有些时候一个好的比喻能胜过很多句解释。下面两个是我看到的两个很精彩的比喻，拿出来和大家分享一下。 　　我们知道，计算机中有很多概念并不容易理解，有些时候一个好的比喻能胜过很多句解释。下面两个是我看到的两个很精彩的比喻，拿出来和大家分享一下。 　　第一比喻是关于吞吐量(throughput)和延迟(latency)的。如果你要搞网络性能优化，这两个概念是你必须要知道的，它们看似简单实则不是。我相信包括我在内的很多人都曾经认为大的吞吐量就意味着低延迟，高延迟

  3. 所属分类：其它

    • 发布日期：2021-03-23
    • 文件大小：62464
    • 提供者：weixin_38711972

  1. MPI_Mutex:MPI的互斥体仿真-源码

  2. MPI_Mutex MPI的互斥体仿真 用法 该互斥锁旨在锁定特定的远程内存（RM），例如等级0。这意味着充当互斥锁的布尔值位于特定的等级中。但是，当获取关键部分时，任何其他通信都可以是过程安全的。 然后，确保创建将与相应等级一起使用的通信器和窗口。如果所有等级都必须与等级0的RM同步，则它可以是任何world_communicator。 分配使用这种方式。 MPI_Mutex mpi_mutex; MPI_Comm mutex_Comm; MPI_Win win_

  3. 所属分类：其它

    • 发布日期：2021-03-19
    • 文件大小：7168
    • 提供者：weixin_42166261

  1. 线程池.zip，互斥锁+条件变量+队列，实现线程池，包括线程池的创建，塞任务，和销毁线程池

  2. 线程池

  3. 所属分类：Linux

    • 发布日期：2021-02-23
    • 文件大小：5120
    • 提供者：qq_45743563

  1. Mutexcache-Python：在Python中动态创建的，缓存的互斥量-源码

  2. 互斥缓存-Python 一个小型实用程序库，用于基于缓存键动态创建互斥体。 用例 假设您正在实现一个graphql服务器，其对象字段彼此独立地异步解析。 多个字段执行相同的操作，因此应使用互斥锁和一些基本缓存来确保数据库查询最多发生一次。 如果您有这些对象的数组，则它们突然都使用相同的互斥量，这可能会降低性能。 动态创建多个短期的互斥对象，而不是使用一个互斥对象来全部统治它们，每个对象可以独立于其他解析对象使用。 通过为互斥锁使用与用于缓存检查相同的缓存键，几乎可以透明地使用动态创建的互斥锁

  3. 所属分类：其它

    • 发布日期：2021-02-18
    • 文件大小：8192
    • 提供者：weixin_42143161

  1. distlock：golang中分布式锁的通用组件，支持redis和postgresql-源码

  2. 开锁 通用的Golang分布式锁组件，更多使用案例详见 司机清单 若有意向贡献未完成的驱动代码，请通过或邮箱249008728qq.com联系我 司机 代码完成度 测试完成度 依赖包 使用说明 Redis 100％ 100％ 详见 pgsql 100％ 100％ 详见 等 未完成 未测试 详见 etcdv3 未完成 未测试 详见 方法说明 配置项mutex.OptFunc以及返回值锁的使用详见 NewMutex（名称字符串，optFuncs ... mutex.OptFunc）（

  3. 所属分类：其它

    • 发布日期：2021-02-05
    • 文件大小：17408
    • 提供者：weixin_42131405

  1. redis-game-transaction：在大型游戏中经常使用分散，分散中因为游戏逻辑会常游戏事务，可以通过redis特性我们可以实现分布式锁和分布式事务。很多redis赋予不支持redis的事务特性。这个框架已经解决了分布式服务器下的

  2. Redis-分布式-事务 在大型游戏中经常使用分布式，分布式中因为游戏逻辑会经常进行游戏事务，通过redis特性我们可以实现分布式锁和分布式事务。很多redis分配不支持redis的事务特性。支持独占锁，共享锁，读写锁，并且支持事务提交失败情况下的回滚操作，让开发者可以有更多时间侧重游戏逻辑。此框架已经上线手游项目两年，经过百万级DAU验证，稳定运行。 互斥锁使用例子 可参考test下的实体。 生成事务原因，GameTransactionCauseImpl里面构造。 生成锁实体，GameTran

  3. 所属分类：其它

    • 发布日期：2021-02-04
    • 文件大小：138240
    • 提供者：weixin_42179184

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

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

  3. 所属分类：其它

    • 发布日期：2021-01-21
    • 文件大小：144384
    • 提供者：weixin_38674409
« 1 2 3 4 5 67 8 9 10 11 ... 36 »