mutex

import "github.com/juju/mutex/v2"

Overview
Index

Overview

package mutex provides a named machine level mutex shareable between processes.

Mutexes have names. Each each name, only one mutex for that name can be acquired at the same time, within and across process boundaries. If a process dies while the mutex is held, the mutex is automatically released.

The Linux/MacOS implementation uses flock, while the Windows implementation uses a named mutex.

Index

Variables
type Clock
type Releaser
- func Acquire(spec Spec) (Releaser, error)
type Spec
- func (s *Spec) Validate() error

Package files

doc.go errors.go legacy_mutex_linux.go mutex.go mutex_flock.go

Variables

var (
    ErrTimeout   = errors.New("timeout acquiring mutex")
    ErrCancelled = errors.New("cancelled acquiring mutex")
)

type Clock

type Clock interface {
    // After waits for the duration to elapse and then sends the
    // current time on the returned channel.
    After(time.Duration) <-chan time.Time

    // Now returns the current clock time.
    Now() time.Time
}

Clock provides an interface for dealing with clocks.

type Releaser

type Releaser interface {
    // Release releases the mutex. Release may be called multiple times, but
    // only the first call will release this instance of the mutex. Release is
    // unable to release the mutex successfully it will call panic to forcibly
    // release the mutex.
    Release()
}

Releaser defines the Release method that is the only thing that can be done to a acquired mutex.

func Acquire

func Acquire(spec Spec) (Releaser, error)

Acquire will attempt to acquire the named mutex. If the Timout value is hit, ErrTimeout is returned. If the Cancel channel is signalled, ErrCancelled is returned.

type Spec

type Spec struct {
    // Name is required, and must start with a letter and contain at most
    // 40 letters, numbers or dashes.
    Name string

    // Clock must be provided and is exposed for testing purposes.
    Clock Clock

    // Delay defines how often to check for lock acquisition, for
    // compatibility code that requires polling.
    Delay time.Duration

    // Timeout allows the caller to specify how long to wait. If Timeout
    // is zero, then the call will block forever.
    Timeout time.Duration

    // Cancel if signalled will cause the Acquire method to return with ErrCancelled.
    Cancel <-chan struct{}
}

Spec defines the name of the mutex and behaviour of the Acquire function.

func (*Spec) Validate

func (s *Spec) Validate() error

Validate checks the attributes of Spec for validity.

Generated by godoc2md

jotadrilo / mutex