Popularity

4.0

Stable

Activity

1.8

Declining

Stars 106

Watchers 2

Forks 8

Last Commit almost 2 years ago

Description

go-lock is a Golang library implementing an efficient read-write lock with the following built-in mechanism: - Mutex - Trylock - No-starve read-write solution

Native sync/Mutex and sync/RWMutex are very powerful and reliable. However, it became a disaster if the lock was not released as expected. Or someone was holding the lock too long at the peak time. It slowed down whole system. Dealing with those cases, go-lock implements TryLock, TryLockWithTimeout and TryLockWithContext function in addition to Lock and Unlock. It provides flexibility to control the resources.

Programming language: Go

License: Apache License 2.0

Tags: Go Tools Go Golang Mutex Trylock Spinlock Readwritelock

Latest version: v1.0.1

go-lock alternatives and similar packages

Based on the "Go Tools" category.
Alternatively, view go-lock alternatives based on common mentions on social networks and blogs.

JuiceFS

9.5 9.7 go-lock VS JuiceFS

JuiceFS is a distributed POSIX file system built on top of Redis and S3.
go-callvis

9.1 2.9 go-lock VS go-callvis

Visualize call graph of a Go program using Graphviz

InfluxDB - Power Real-Time Data Analytics at Scale

Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.

Promo www.influxdata.com

OctoLinker

9.0 7.0 L5 go-lock VS OctoLinker

OctoLinker — Links together, what belongs together
JSON-to-Go

8.9 2.4 go-lock VS JSON-to-Go

Translates JSON into a Go type in your browser instantly (original)
gb

8.6 0.0 go-lock VS gb

DISCONTINUED. An easy to use project based build tool for the Go programming language.
go-critic

7.9 7.8 go-lock VS go-critic

The most opinionated Go source code linter for code audit.
kube-prompt

7.9 0.0 go-lock VS kube-prompt

An interactive kubernetes client featuring auto-complete.
The Go Play Space

7.3 0.0 go-lock VS The Go Play Space

Advanced Go Playground frontend written in Go, with syntax highlighting, turtle graphics mode, and more
depth

7.1 0.0 go-lock VS depth

Visualize Go Dependency Trees
richgo

6.9 1.2 go-lock VS richgo

Enrich `go test` outputs with text decorations.
Peanut

6.8 9.1 go-lock VS Peanut

🐺 Deploy Databases and Services Easily for Development and Testing Pipelines.
golang-tutorials

6.6 0.0 go-lock VS golang-tutorials

Golang Tutorials. Learn Golang from Scratch with simple examples.
xdg-go

6.5 6.7 go-lock VS xdg-go

Go implementation of the XDG Base Directory Specification and XDG user directories
rts

5.3 0.0 go-lock VS rts

RTS: request to struct. Generates Go structs from JSON server responses.
typex

5.0 2.8 go-lock VS typex

[TOOL/CLI] - Filter and examine Go type structures, interfaces and their transitive dependencies and relationships. Export structural types as TypeScript value object or bare type representations.
golang-ipc

4.9 3.7 go-lock VS golang-ipc

Golang Inter-process communication library for Window, Mac and Linux.
roumon

4.7 6.3 go-lock VS roumon

Universal goroutine monitor using pprof and termui
colorgo

4.4 0.0 go-lock VS colorgo

Colorize (highlight) `go build` command output
Viney's go-cache

4.3 0.0 go-lock VS Viney's go-cache

A flexible multi-layer Go caching library to deal with in-memory and shared cache by adopting Cache-Aside pattern.
gothanks

4.2 0.0 go-lock VS gothanks

GoThanks automatically stars Go's official repository and your go.mod github dependencies, providing a simple way to say thanks to the maintainers of the modules you use and the contributors of Go itself.
zb

4.1 0.0 go-lock VS zb

an opinionated repo based tool for linting, testing and building go source
goroutines

3.9 0.0 go-lock VS goroutines

It is an efficient, flexible, and lightweight goroutine pool. It provides an easy way to deal with concurrent tasks with limited resource.
gotestdox

3.9 6.2 go-lock VS gotestdox

A tool for formatting Go test results as readable documentation
version

3.7 3.3 go-lock VS version

Go package to present your CLI version with an upgrade notice.
terminal-Task

3.6 0.0 go-lock VS terminal-Task

Terminal tasks todo with reminder tool for geek
PDF to Image Converter Using Golang

3.5 0.0 go-lock VS PDF to Image Converter Using Golang

This project will help you to convert PDF file to IMAGE using golang.
An exit strategy for go routines.

3.3 0.0 go-lock VS An exit strategy for go routines.

DISCONTINUED. An exit strategy for go routines
go-james

3.2 0.0 go-lock VS go-james

DISCONTINUED. James is your butler and helps you to create, build, debug, test and run your Go projects
igo

3.2 0.0 go-lock VS igo

Improved Go Syntax (transpiler)
generator-go-lang

3.1 0.6 go-lock VS generator-go-lang

DISCONTINUED. A Yeoman generator to get new Go projects started.
Paymail Inspector

3.0 8.0 go-lock VS Paymail Inspector

:money_with_wings: CLI app for interacting with paymail service providers
go-pkg-complete

2.8 0.0 go-lock VS go-pkg-complete

bash completion for go and wgo
gomodrun

2.3 3.6 go-lock VS gomodrun

The forgotten go tool that executes and caches binaries included in go.mod files.
docs

2.3 2.0 go-lock VS docs

Automatically generate RESTful API documentation for GO projects - aligned with Open API Specification standard
rescached

2.2 6.3 go-lock VS rescached

DISCONTINUED. [mirror] Resolver (DNS) cache daemon. See https://sr.ht/~shulhan/rescached [Moved to: https://github.com/shuLhan/rescached]
go-sanitize

2.2 6.2 go-lock VS go-sanitize

:bathtub: Golang library of simple to use sanitation functions
Goenv

2.1 5.4 go-lock VS Goenv

🐺 Manage Your Applications Go Environment.
go-whatsonchain

2.0 6.7 go-lock VS go-whatsonchain

:link: Unofficial golang implementation for the WhatsOnChain API
channelize

2.0 0.6 go-lock VS channelize

A websocket framework to manage outbound streams. Allowing to have multiple channels per connection that includes public and private channels.
Proofable

1.9 0.0 go-lock VS Proofable

General purpose proving framework for certifying digital assets to public blockchains
Sonic

1.8 8.7 go-lock VS Sonic

Sonic is a Go library for network and I/O programming that provides developers with a consistent asynchronous model, with a focus on achieving the lowest possible latency and jitter in Go.
modver

1.7 5.4 go-lock VS modver

Compare two versions of a Go module to check the version-number change required (major, minor, or patchlevel), according to semver rules.
ciiigo

1.4 7.3 go-lock VS ciiigo

[mirror] Go static website generator with asciidoc markup language
go-preev

1.3 0.0 go-lock VS go-preev

DISCONTINUED. :link: Unofficial golang implementation for the Preev API
Crypt

1.3 0.0 go-lock VS Crypt

Crypt implementation in pure Go
redispubsub

1.3 10.0 go-lock VS redispubsub

Redis Streams queue driver for https://godoc.org/gocloud.dev/pubsub package
retry

1.2 4.7 go-lock VS retry

Small, full-featured, 100% test-covered retry package for golang.
golang-ifood-sdk

1.2 0.0 go-lock VS golang-ifood-sdk

Golang Ifood API SDK
try

1.1 0.0 go-lock VS try

A go package that offers a try/catch statement block.
num30/go-cache

1.1 0.0 go-lock VS num30/go-cache

An in-memory key:value store/cache (similar to Memcached) library that takes advantage of Go Generics

* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.

Do you think we are missing an alternative of go-lock or a related project?

Add another 'Go Tools' Package

Popular Comparisons

README

go-lock

go-lock is a Golang library implementing an effcient read-write lock with the following built-in mechanism:

Mutex with timeout mechanism
Trylock
No-starve read-write solution

Native sync/Mutex and sync/RWMutex are very powerful and reliable. However, it became a disaster if the lock was not released as expected. Or, someone was holding the lock too long at the peak time leading whole system blocked. Dealing with those cases, go-lock implements TryLock, TryLockWithTimeout and TryLockWithContext function in addition to Lock and Unlock. It provides flexibility to control the resources.

Installation

go get github.com/viney-shih/go-lock

Example

package main

import (
    "fmt"
    "sync/atomic"
    "time"

    lock "github.com/viney-shih/go-lock"
)

func main() {
    // set RWMutex with CAS mechanism (CASMutex).
    var rwMut lock.RWMutex = lock.NewCASMutex()
    // set default value
    count := int32(0)

    // block here
    rwMut.Lock()
    go func() {
        time.Sleep(50 * time.Millisecond)
        fmt.Println("Now is", atomic.AddInt32(&count, 1)) // Now is 1
        rwMut.Unlock()
    }()

    // waiting for previous goroutine releasing the lock, and locking it again
    rwMut.Lock()
    fmt.Println("Now is", atomic.AddInt32(&count, 2)) // Now is 3

    // TryLock without blocking
    // Return false, because the lock is not released.
    fmt.Println("Return", rwMut.TryLock())

    // RTryLockWithTimeout without blocking
    // Return false, because the lock is not released.
    fmt.Println("Return", rwMut.RTryLockWithTimeout(50*time.Millisecond))

    // TryLockWithContext without blocking
    ctx, cancel := context.WithTimeout(context.TODO(), 50*time.Millisecond)
    defer cancel()
    // Return false, because the lock is not released.
    fmt.Println("Return", rwMut.TryLockWithContext(ctx))

    // release the lock in the end.
    rwMut.Unlock()

    // Output:
    // Now is 1
    // Now is 3
    // Return false
    // Return false
    // Return false
}

[More examples](./cas_test.go)
Full API documentation

Benchmarks

Run on MacBook Pro (Retina, 15-inch, Mid 2015) 2.5 GHz Quad-Core Intel Core i7 16 GB 1600 MHz DDR3 using Go 1.15.2
Run with 1, 2, 4, 8 and 16 cpu to show it scales well...16 is double the # of logical cores on this machine.

go test -cpu=1,2,4,8,16 -bench=. -benchmem=true

goos: darwin
goarch: amd64
pkg: github.com/viney-shih/go-lock

(sync.RWMutex)
BenchmarkRWMutexLock                        42591765            27.4 ns/op         0 B/op          0 allocs/op
BenchmarkRWMutexLock-2                      42713179            27.5 ns/op         0 B/op          0 allocs/op
BenchmarkRWMutexLock-4                      44348323            27.5 ns/op         0 B/op          0 allocs/op
BenchmarkRWMutexLock-8                      44135148            27.9 ns/op         0 B/op          0 allocs/op
BenchmarkRWMutexLock-16                     43566165            27.5 ns/op         0 B/op          0 allocs/op
BenchmarkConcurrentRWMutexLock              42971319            27.5 ns/op         0 B/op          0 allocs/op
BenchmarkConcurrentRWMutexLock-2            20131005            57.5 ns/op         0 B/op          0 allocs/op
BenchmarkConcurrentRWMutexLock-4            10752337           115 ns/op           0 B/op          0 allocs/op
BenchmarkConcurrentRWMutexLock-8            11434335           105 ns/op           0 B/op          0 allocs/op
BenchmarkConcurrentRWMutexLock-16           10495626           109 ns/op           0 B/op          0 allocs/op
BenchmarkConcurrent50RWMutexLock            27979630            42.8 ns/op         0 B/op          0 allocs/op
BenchmarkConcurrent50RWMutexLock-2          13037742            86.6 ns/op         0 B/op          0 allocs/op
BenchmarkConcurrent50RWMutexLock-4           9143397           134 ns/op           0 B/op          0 allocs/op
BenchmarkConcurrent50RWMutexLock-8           8335652           139 ns/op           0 B/op          0 allocs/op
BenchmarkConcurrent50RWMutexLock-16          7876855           150 ns/op           0 B/op          0 allocs/op

(ChanMutex)
BenchmarkChanMutexLock                      22619928            51.8 ns/op         0 B/op          0 allocs/op
BenchmarkChanMutexLock-2                    22769630            51.6 ns/op         0 B/op          0 allocs/op
BenchmarkChanMutexLock-4                    23096103            51.7 ns/op         0 B/op          0 allocs/op
BenchmarkChanMutexLock-8                    22627267            51.1 ns/op         0 B/op          0 allocs/op
BenchmarkChanMutexLock-16                   23092266            51.7 ns/op         0 B/op          0 allocs/op
BenchmarkConcurrentChanMutexLock            23422556            51.8 ns/op         0 B/op          0 allocs/op
BenchmarkConcurrentChanMutexLock-2           6101949           201 ns/op           0 B/op          0 allocs/op
BenchmarkConcurrentChanMutexLock-4           5882083           200 ns/op           0 B/op          0 allocs/op
BenchmarkConcurrentChanMutexLock-8           5827183           211 ns/op           0 B/op          0 allocs/op
BenchmarkConcurrentChanMutexLock-16          5577098           215 ns/op           0 B/op          0 allocs/op
BenchmarkChanMutexTryLock                   22272500            51.8 ns/op         0 B/op          0 allocs/op
BenchmarkChanMutexTryLock-2                 23004806            52.2 ns/op         0 B/op          0 allocs/op
BenchmarkChanMutexTryLock-4                 22461870            52.3 ns/op         0 B/op          0 allocs/op
BenchmarkChanMutexTryLock-8                 22901328            53.8 ns/op         0 B/op          0 allocs/op
BenchmarkChanMutexTryLock-16                22334739            55.4 ns/op         0 B/op          0 allocs/op
BenchmarkConcurrentChanMutexTryLock         22112250            53.9 ns/op         0 B/op          0 allocs/op
BenchmarkConcurrentChanMutexTryLock-2       13806072            85.0 ns/op         0 B/op          0 allocs/op
BenchmarkConcurrentChanMutexTryLock-4       45892635            32.6 ns/op         0 B/op          0 allocs/op
BenchmarkConcurrentChanMutexTryLock-8       396310569            2.86 ns/op        0 B/op          0 allocs/op
BenchmarkConcurrentChanMutexTryLock-16      512990590            2.35 ns/op        0 B/op          0 allocs/op

(CASMutex)
BenchmarkCASMutexLock                        6160122           186 ns/op          96 B/op          1 allocs/op
BenchmarkCASMutexLock-2                      7507022           156 ns/op          96 B/op          1 allocs/op
BenchmarkCASMutexLock-4                      7646648           156 ns/op          96 B/op          1 allocs/op
BenchmarkCASMutexLock-8                      7559616           156 ns/op          96 B/op          1 allocs/op
BenchmarkCASMutexLock-16                     7576237           158 ns/op          96 B/op          1 allocs/op
BenchmarkConcurrentCASMutexLock              6375879           185 ns/op          96 B/op          1 allocs/op
BenchmarkConcurrentCASMutexLock-2            1690890           706 ns/op         251 B/op          3 allocs/op
BenchmarkConcurrentCASMutexLock-4            1677104           714 ns/op         255 B/op          3 allocs/op
BenchmarkConcurrentCASMutexLock-8            1808582           639 ns/op         255 B/op          3 allocs/op
BenchmarkConcurrentCASMutexLock-16           1918422           622 ns/op         255 B/op          3 allocs/op
BenchmarkConcurrent50CASMutexLock            5650274           210 ns/op          96 B/op          1 allocs/op
BenchmarkConcurrent50CASMutexLock-2          1698381           707 ns/op         247 B/op          3 allocs/op
BenchmarkConcurrent50CASMutexLock-4          1697070           707 ns/op         255 B/op          3 allocs/op
BenchmarkConcurrent50CASMutexLock-8          1809859           655 ns/op         255 B/op          3 allocs/op
BenchmarkConcurrent50CASMutexLock-16         1801652           646 ns/op         256 B/op          4 allocs/op
BenchmarkCASMutexTryLock                     6593228           182 ns/op          96 B/op          1 allocs/op
BenchmarkCASMutexTryLock-2                   7703084           154 ns/op          96 B/op          1 allocs/op
BenchmarkCASMutexTryLock-4                   7790750           151 ns/op          96 B/op          1 allocs/op
BenchmarkCASMutexTryLock-8                   7756263           152 ns/op          96 B/op          1 allocs/op
BenchmarkCASMutexTryLock-16                  7741186           152 ns/op          96 B/op          1 allocs/op
BenchmarkConcurrentCASMutexTryLock           6509828           189 ns/op          96 B/op          1 allocs/op
BenchmarkConcurrentCASMutexTryLock-2        14058355            82.2 ns/op        17 B/op          0 allocs/op
BenchmarkConcurrentCASMutexTryLock-4        16875369            71.4 ns/op         8 B/op          0 allocs/op
BenchmarkConcurrentCASMutexTryLock-8        10985379           109 ns/op           4 B/op          0 allocs/op
BenchmarkConcurrentCASMutexTryLock-16       12405752           104 ns/op           1 B/op          0 allocs/op
BenchmarkConcurrent50CASMutexTryLock         5631146           204 ns/op          96 B/op          1 allocs/op
BenchmarkConcurrent50CASMutexTryLock-2       6518946           182 ns/op          61 B/op          0 allocs/op
BenchmarkConcurrent50CASMutexTryLock-4       6937346           174 ns/op          43 B/op          0 allocs/op
BenchmarkConcurrent50CASMutexTryLock-8       6493034           182 ns/op          39 B/op          0 allocs/op
BenchmarkConcurrent50CASMutexTryLock-16      6177854           202 ns/op          41 B/op          0 allocs/op
PASS

References

License

Apache-2.0

*Note that all licence references and agreements mentioned in the go-lock README section above are relevant to that project's source code only.

go-lock

go-lock is a lock library implementing read-write mutex and read-write trylock without starvation

Description

go-lock alternatives and similar packages

Popular Comparisons

README

go-lock

Installation

Example

Benchmarks

References

License