package concurrent

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

Dependency Relation
	imports 6 packages, and imported by 2 packages

Involved Source Files

	      executor.go
	      go_above_19.go
	      unbounded_executor.go
Package-Level Type Names (total 3, all are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Executor (interface)

		Methods (only one, which is exported)
			( T) Go(handler func(ctx context.Context))
		Implemented By (at least one exported)
			*UnboundedExecutor

	 type Map (struct)

		Fields (total 5, in which 1 are exported)
			Map sync.Map
			/* 4 unexporteds ... *//* 4 unexporteds: */
			Map.dirty map[interface{}]*sync.entry
				dirty contains the portion of the map's contents that require mu to be
				held. To ensure that the dirty map can be promoted to the read map quickly,
				it also includes all of the non-expunged entries in the read map.

				Expunged entries are not stored in the dirty map. An expunged entry in the
				clean map must be unexpunged and added to the dirty map before a new value
				can be stored to it.

				If the dirty map is nil, the next write to the map will initialize it by
				making a shallow copy of the clean map, omitting stale entries.

			Map.misses int
				misses counts the number of loads since the read map was last updated that
				needed to lock mu to determine whether the key was present.

				Once enough misses have occurred to cover the cost of copying the dirty
				map, the dirty map will be promoted to the read map (in the unamended
				state) and the next store to the map will make a new dirty copy.

			Map.mu sync.Mutex
			Map.read atomic.Value
				read contains the portion of the map's contents that are safe for
				concurrent access (with or without mu held).

				The read field itself is always safe to load, but must only be stored with
				mu held.

				Entries stored in read may be updated concurrently without mu, but updating
				a previously-expunged entry requires that the entry be copied to the dirty
				map and unexpunged with mu held.
				// readOnly

		Methods (total 8, in which 6 are exported)
			(*T) Delete(key interface{})
				Delete deletes the value for a key.

			(*T) Load(key interface{}) (value interface{}, 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.

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

			(*T) LoadOrStore(key, value interface{}) (actual interface{}, 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.

			(*T) Range(f func(key, value interface{}) 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, Range may reflect any mapping for that key
				from any point during the Range call.

				Range may be O(N) with the number of elements in the map even if f returns
				false after a constant number of calls.

			(*T) Store(key, value interface{})
				Store sets the value for a key.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) dirtyLocked()
			(*T) missLocked()
		As Outputs Of (at least one exported)
			func NewMap() *Map
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var github.com/json-iterator/go.cfgCache *Map

	 type UnboundedExecutor (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			activeGoroutines map[string]int
			activeGoroutinesMutex *sync.Mutex
			cancel context.CancelFunc
			ctx context.Context
		Methods (total 5, in which 4 are exported)
			(*T) Go(handler func(ctx context.Context))
			(*T) Stop()
			(*T) StopAndWait(ctx context.Context)
			(*T) StopAndWaitForever()
			/* one unexported ... *//* one unexported: */
			(*T) checkGoroutines() bool
		Implements (at least one exported)
			*T : Executor
		As Outputs Of (at least one exported)
			func NewUnboundedExecutor() *UnboundedExecutor
		As Types Of (only one, which is exported)
			  var GlobalUnboundedExecutor *UnboundedExecutor


Package-Level Functions (total 2, both are exported)

	 func NewMap() *Map
	 func NewUnboundedExecutor() *UnboundedExecutor
Package-Level Variables (total 3, all are exported)

	  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

	  var LogInfo func(event string, properties ...interface{})
	  var LogPanic func(recovered interface{}, properties ...interface{}) interface{}
Package-Level Constants (only one, which is exported)

	const StopSignal = "STOP!"

The pages are generated with Golds v0.3.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 @Go100and1 (reachable from the left QR code) to get the latest news of Golds.