Displaying 1 to 20 from 27 results

lock - Lock library to provide serialized execution of PHP code.

  •    PHP

This library helps executing critical code in concurrent situations. The package is in the namespace malkusch\lock.

AtomicKit - Concurrency made simple in Swift.

  •    Swift

Concurrency made simple in Swift. AtomicKit is a Swift framework designed to ease dealing with concurrency in Swift projects.




mutexify - Bike shed mutex lock implementation

  •    Javascript

Hasn't this been done before? Yes, but the specific semantics of this made some of my code simpler.mutexify guarantees that the order that a mutex was requested in is the order that access will be given.

fast-mutex - FastMutex implementation using LocalStorage and promises

  •    Javascript

Implementation of FastMutex for mutual exclusion locks using LocalStorage. Uses promises to make it more readable, especially when used with async/await.Mutual Exclusion locks are generally not necessary in javascript applications as they are single threaded. There are, however, exceptions. WebWorkers, multiple tabs (and perhaps iframes in the future) give us the ability to run multiple concurrent javascript processes, and therefore, may require the locking of resources to prevent race conditions.

redis-exp-lock-js - Client-side abstraction for Redis-based, expiring distributed mutex

  •    CoffeeScript

Uses Redis to provide a mechanism for distributed mutual exclusion. If you want to prevent multiple nodes on a network from accessing a resource at the same time, this is for you. This lock implementation uses a finite but configurable expiration time. Unlike most SETNX-based solutions, this uses Redis's Lua functionality. The result is cleaner code and fewer race conditions. Lock expiration is handled by the Redis server itself, using the EXPIRE command, thus eliminating the need for precise time synchronization between your application hosts.


level-mutex - Mutex read/write lock for levelup.

  •    Javascript

level-mutex is an abstract "lock" around a levelup store. What it does is cycle between reads and writes, allowing all writes to return in order while queuing all reads, then running all reads and returning in order, then writing all the pending writes again. level-mutex uses node.js' single threaded nature to your advantage so that you can maintain a higher order locking structure to insure various types of read-on-write consistency semantics. This is currently used in couchup to ensure users cannot update a document without providing the latest revision.

monogamy - Add table-level database locking to ActiveRecord

  •    Ruby

Adds table-level locking to ActiveRecord 4.2 and 5.0. MySQL and PostgreSQL are supported. While your code is inside the block, it will have exclusive read and write access to the model's table.

l8 - Task manager for javascript with promises, dataflows and actors

  •    Javascript

l8 is an *experimental* pthread/erlang inspired task manager for javascript. Simple tasks becomes 'paroles', complex tasks become functions broken in 'steps'. l8 comes with synchronisation and distribution tools including semaphores, mutexes, message queues, generators, actors and socket.io proxied actors, among others.

semaphorejs - A functional-style Semaphore for managing concurrent access to a resource

  •    Javascript

A functional-style Semaphore for managing concurrent access to a resource with async functions and Promises. Most of the time, you should use limit() instead of creating a Semaphore yourself. limit() preserves your existing API and simply "decorates" the async function with rate limiting.

locks - Mutex locks, Read/Write locks, Condition variables and Semaphores in JavaScript

  •    Javascript

Locks implements locking/synchronization mechanisms that have traditionally been used for protecting shared memory between multiple threads. JavaScript is inherently single threaded and does not suffer from these security and stability issues. However, because of its asynchronous eventy nature JavaScript can still benefit from making particular operations wait for the completion of others.

yamc - C++ mutex collections, platform-independent header-only C++11 library.

  •    C++

C++ mutex (mutual exclusion primitive for multi-threading) collections. This is header-only, cross-platform, no external dependency C++11 library. All mutex types in this library are compatible with corresponding mutex types in C++ Standard Library. The following toy example use spinlock mutex (yamc::spin_ttas::mutex) and scoped locking by std::lock_guard<>.

mongo - Light-weight utilities to augment, not replace the Python MongoDB driver.

  •    Python

Marrow Mongo is a collection of small, focused utilities written to enhance use of the PyMongo native MongoDB driver without the overhead, glacial update cycle, complexity, and head-space requirements of a full active record object document mapper. Additionally, it provides a very light-weight database connection plugin for the WebCore web framework and Python standard logging adapter to emit logs to MongoDB. Additional documentation is provided in the form of an online reference manual.

semaphore - Wrapping sync.Mutex for familiar semaphore api

  •    Go

Wrapping sync.Mutex for familiar semaphore api

await-semaphore - Awaitable semaphore/mutex

  •    TypeScript

Also includes Mutex as a convenience for new Semaphore(1). Create a new semaphore with the given count.

go-csync - Golang: contex-aware synchronization primitives (mutex).

  •    Go

Golang: context-aware synchronization primitives. Only has a mutex right now.

go-deadlock - Online deadlock detection in go (golang)

  •    Go

Deadlocks happen and are painful to debug. go-deadlock provides (RW)Mutex drop-in replacements for sync.(RW)Mutex. It would not work if you create a spaghetti of channels. Mutexes only.