package concurrent

Import Path
	github.com/modern-go/concurrent (on go.dev)

Dependency Relation
	imports 10 packages, and imported by one package

Involved Source Files

	    executor.go
	    go_above_19.go
	    log.go
	    unbounded_executor.go
Package-Level Type Names (total 3)

	/* sort by: alphabet | popularity */
	 type Executor (interface)
		Executor replace go keyword to start a new goroutine
		the goroutine should cancel itself if the context passed in has been cancelled
		the goroutine started by the executor, is owned by the executor
		we can cancel all executors owned by the executor just by stop the executor itself
		however Executor interface does not Stop method, the one starting and owning executor
		should use the concrete type of executor, instead of this interface.

		Methods (only one)
			( Executor) Go(handler func(ctx context.Context))
				Go starts a new goroutine controlled by the context

		Implemented By (at least one exported)
			*UnboundedExecutor

	 type Map (struct)
		Map is a wrapper for sync.Map introduced in go1.9

		Fields (only one)
			Map sync.Map
		Methods (total 10)
			(*Map) Clear()
				Clear deletes all the entries, resulting in an empty Map.

			(*Map) CompareAndDelete(key, old any) (deleted bool)
				CompareAndDelete deletes the entry for key if its value is equal to old.
				The old value must be of a comparable type.
				
				If there is no current value for key in the map, CompareAndDelete
				returns false (even if the old value is the nil interface value).

			(*Map) CompareAndSwap(key, old, new any) (swapped bool)
				CompareAndSwap swaps the old and new values for key
				if the value stored in the map is equal to old.
				The old value must be of a comparable type.

			(*Map) Delete(key any)
				Delete deletes the value for a key.
				If the key is not in the map, Delete does nothing.

			(*Map) Load(key any) (value any, ok bool)
				Load returns the value stored in the map for a key, or nil if no
				value is present.
				The ok result indicates whether value was found in the map.

			(*Map) LoadAndDelete(key any) (value any, loaded bool)
				LoadAndDelete deletes the value for a key, returning the previous value if any.
				The loaded result reports whether the key was present.

			(*Map) LoadOrStore(key, value any) (actual any, loaded bool)
				LoadOrStore returns the existing value for the key if present.
				Otherwise, it stores and returns the given value.
				The loaded result is true if the value was loaded, false if stored.

			(*Map) Range(f func(key, value any) bool)
				Range calls f sequentially for each key and value present in the map.
				If f returns false, range stops the iteration.
				
				Range does not necessarily correspond to any consistent snapshot of the Map's
				contents: no key will be visited more than once, but if the value for any key
				is stored or deleted concurrently (including by f), Range may reflect any
				mapping for that key from any point during the Range call. Range does not
				block other methods on the receiver; even f itself may call any method on m.
				
				Range may be O(N) with the number of elements in the map even if f returns
				false after a constant number of calls.

			(*Map) Store(key, value any)
				Store sets the value for a key.

			(*Map) Swap(key, value any) (previous any, loaded bool)
				Swap swaps the value for a key and returns the previous value if any.
				The loaded result reports whether the key was present.

		As Outputs Of (at least one exported)
			func NewMap() *Map

	 type UnboundedExecutor (struct)
		UnboundedExecutor is a executor without limits on counts of alive goroutines
		it tracks the goroutine started by it, and can cancel them when shutdown

		Fields (only one)
			HandlePanic func(recovered interface{}, funcName string)
		Methods (total 4)
			(*UnboundedExecutor) Go(handler func(ctx context.Context))
				Go starts a new goroutine and tracks its lifecycle.
				Panic will be recovered and logged automatically, except for StopSignal

			(*UnboundedExecutor) Stop()
				Stop cancel all goroutines started by this executor without wait

			(*UnboundedExecutor) StopAndWait(ctx context.Context)
				StopAndWait cancel all goroutines started by this executor and wait.
				Wait can be cancelled by the context passed in.

			(*UnboundedExecutor) StopAndWaitForever()
				StopAndWaitForever cancel all goroutines started by this executor and
				wait until all goroutines exited

		Implements (at least one exported)
			*UnboundedExecutor : Executor
		As Outputs Of (at least one exported)
			func NewUnboundedExecutor() *UnboundedExecutor
		As Types Of (only one)
			  var GlobalUnboundedExecutor *UnboundedExecutor


Package-Level Functions (total 2)

	 func NewMap() *Map
		NewMap creates a thread safe Map

	 func NewUnboundedExecutor() *UnboundedExecutor
		NewUnboundedExecutor creates a new UnboundedExecutor,
		UnboundedExecutor can not be created by &UnboundedExecutor{}
		HandlePanic can be set with a callback to override global HandlePanic


Package-Level Variables (total 4)

	  var ErrorLogger *log.Logger
		ErrorLogger is used to print out error, can be set to writer other than stderr

	  var GlobalUnboundedExecutor *UnboundedExecutor
		GlobalUnboundedExecutor has the life cycle of the program itself
		any goroutine want to be shutdown before main exit can be started from this executor
		GlobalUnboundedExecutor expects the main function to call stop
		it does not magically knows the main function exits

	  var HandlePanic func(recovered interface{}, funcName string)
		HandlePanic logs goroutine panic by default

	  var InfoLogger *log.Logger
		InfoLogger is used to print informational message, default to off

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.