concurrent-map - a thread-safe concurrent map for go

•    Go

As explained here and here, the map type in Go doesn't support concurrent reads and writes. concurrent-map provides a high-performance solution to this by sharding the map with minimal time spent waiting for locks. The package is now imported under the "cmap" namespace.

Overdrive - ⚡️ Fast async task based Swift framework with focus on type safety, concurrency and multi threading

•    Swift

Our apps constantly do work. The faster you react to user input and produce an output, the more likely is that the user will continue to use your application. As our applications grow in complexity, the more and more work needs to be done. You need to start thinking about how to categorize and optimize work, how to make that work more efficient, more optimized and finally, faster. In most cases that doesn’t end very well because you need to know a lot about concurrency, multithreading etc. - it’s a very complex field. You need to know all API specifics before you are able to write something. Overdrive was created as a result of that struggle. It is a framework that exposes several simple concepts which are made on top of complex system frameworks that enable multithreading, concurrency and most importantly, more speed.

Overdrive - ⚡️ Fast async task based Swift framework with focus on type safety, concurrency and multi threading

•    Swift

Our apps constantly do work. The faster you react to user input and produce an output, the more likely is that the user will continue to use your application. As our applications grow in complexity, the more and more work needs to be done. You need to start thinking about how to categorize and optimize work, how to make that work more efficient, more optimized and finally, faster. In most cases that doesn’t end very well because you need to know a lot about concurrency, multithreading etc. - it’s a very complex field. You need to know all API specifics before you are able to write something. Overdrive was created as a result of that struggle. It is a framework that exposes several simple concepts which are made on top of complex system frameworks that enable multithreading, concurrency and most importantly, more speed.

easyloggingpp - Single header C++ logging library

•    C++

Single header C++ logging library. It is extremely powerful, extendable, light-weight, fast performing, thread and type safe and consists of many built-in features. It provides ability to write logs in your own customized format. It also provide support for logging your classes, third-party libraries, STL and third-party containers etc.

fucking-java-concurrency - 🎏 simple show cases of java concurrency problems

•    Java

🎏 simple show cases of java concurrency problems

java-concurrency - Checklist for code reviews

Checklist for code reviews

concurrencpp - Modern concurrency for C++

•    C++

concurrencpp is a tasking library for C++ allowing developers to write highly concurrent applications easily and safely by using tasks, executors and coroutines. By using concurrencpp applications can break down big procedures that need to be processed asynchronously into smaller tasks that run concurrently and work in a co-operative manner to achieve the wanted result. concurrencpp also allows applications to write parallel algorithms easily by using parallel coroutines. concurrencpp is a task-centric library. A task is an asynchronous operation. Tasks offer a higher level of abstraction for concurrent code than traditional thread-centric approaches. Tasks can be chained together, meaning that tasks pass their asynchronous result from one to another, where the result of one task is used as if it were a parameter or an intermediate value of another ongoing task. Tasks allow applications to utilize available hardware resources better and scale much more than using raw threads, since tasks can be suspended, waiting for another task to produce a result, without blocking underlying OS-threads. Tasks bring much more productivity to developers by allowing them to focus more on business-logic and less on low-level concepts like thread management and inter-thread synchronization.

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.

rubocop-thread_safety

•    Ruby

Thread-safety analysis for your projects, as an extension to RuboCop. Now you can run rubocop and it will automatically load the RuboCop Thread-Safety cops together with the standard cops.

sled - A high performance lock free map type for go.

•    Go

Sled is a high performance Key/Value store based on a ctrie data structure. Sled is non-blocking and thread safe, meaning it is safe to access from any number of threads simultaneously. Any type of data can be stored in a key, but sled maintains the benefits of the Go type system by enforcing the type. Values must be accessed by passing an empty type value of the same type into the Get method.

ConcurrentSkipList - A light, high-performance, concurrent, thread-safe skip list implementation written in Golang

•    Go

A light, high-performance, concurrent, thread-safe skip list implementation written in Golang.

valkyrie - Go wrapper for handling zero or more errors

•    Go

Valkyrie is a utility that helps you aggregate multiple errors in Go, while maintaining thread safety. For more documentation, you can visit godoc.org.

persist-queue - A thread-safe disk based persistent queue in Python

•    Python

While queuelib and python-pqueue cannot fulfil all of above. After some try, I found it's hard to achieve based on their current implementation without huge code change. this is the motivation to start this project. Here are the results for writing/reading 1000 items to the disk comparing the sqlite3 and file queue.

safemap - Auto generated thread-safe map written in golang.

•    Go

An auto-generated thread-safe map package written in golang. Run safemap -k Key_type -v Val_type to generate a file named Key_type2Val_type.go in currenty package directory. It will search currenty directory for the definitions of Key_type and Val_type, and define a struct Key_type2Val_typeSafeMap in the file. You can also use -n to specify a namespace instead of default Key_type2Value_type in order to avoid conflicts.

Ichor - C++20 thread confinement and dependency injection framework.

•    C++

Ichor, Greek Mythos for ethereal fluid that is the blood of the gods/immortals, is a C++ framework/middleware for thread confinement and dependency injection. Ichor informally stands for "Intuitive Compile-time Hoisted Object Resources".

safetyfast - An Go library of synchronization primitives to help make use of hardware transactional memory (HTM)

•    Go

This is a Go library that implements synchronization primitives over Intel TSX (hardware transactional primitives). Checkout the SafetyFast Project Page.

lfqueue - lock-free FIFO queue by C native built it, easy built cross platform(no extra dependencies needed) , guarantee thread safety memory management ever!

•    C

lock-free FIFO queue by C native built it, easy built cross platform(no extra dependencies needed) , guarantee thread safety memory management ever!

syncem - A simple Ruby decorator to make your objects thread-safe

•    Ruby

Read this blog post: SyncEm: Thread-Safe Decorators in Ruby. Sometimes you have an object that is not thread-safe, but you need to make sure each of its methods is thread-safe, because they deal with some resources, like files or databases and you want them to manage those resources sequentially. This small gem will help you achieve exactly that without any re-design of the objects you already have. Just decorate them with SyncEm thread-safe decorator and that is it.