concurrency

Documentation

Overview

*****************************************************************************

*
*  Description :
*    A very basic and naive implementation of thread pool.
*
****************************************************************************

*****************************************************************************

*
*  Description :
*    A very simple implementation of a mutex with channels.
*    Provides TryLock functionality absent in Go's regular sync.Mutex.
*    See https://github.com/golang/go/issues/6123 for details.
*
****************************************************************************

Index

• type GoRoutinePool
  • func NewGoRoutinePool(numWorkers int) *GoRoutinePool
  • func (p *GoRoutinePool) Schedule(task Task)
  • func (p *GoRoutinePool) Stop()
• type SimpleMutex
  • func NewSimpleMutex() SimpleMutex
  • func (s SimpleMutex) Lock()
  • func (s SimpleMutex) TryLock() bool
  • func (s SimpleMutex) Unlock()
• type Task

Types

type GoRoutinePool

type GoRoutinePool struct {
	// contains filtered or unexported fields
}

func NewGoRoutinePool

func NewGoRoutinePool(numWorkers int) *GoRoutinePool

NewGoRoutinePool allocates a new thread pool with `numWorkers` goroutines.

func (*GoRoutinePool) Schedule

func (p *GoRoutinePool) Schedule(task Task)

Schedule enqueus a closure to run on the GoRoutinePool's goroutines.

func (*GoRoutinePool) Stop

func (p *GoRoutinePool) Stop()

Stop sends a stop signal to all running goroutines.

type SimpleMutex

type SimpleMutex chan struct{}

func NewSimpleMutex

func NewSimpleMutex() SimpleMutex

Creates and returns a new SimpleMutex object.

func (SimpleMutex) Lock

func (s SimpleMutex) Lock()

Acquires a lock on the mutex.

func (SimpleMutex) TryLock

func (s SimpleMutex) TryLock() bool

Attempts to acquire a lock on the mutex. Returns true if the lock has been acquired, false otherwise.

func (SimpleMutex) Unlock

func (s SimpleMutex) Unlock()

Releases the mutex.

type Task

type Task func()

Task represents a work task to be run on the specified thread pool.