par

package standard library
Version: go1.16.6 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 12, 2021 License: BSD-3-Clause Imports: 4 Imported by: 0

Documentation

Overview

Package par implements parallel execution helpers.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Cache

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

Cache runs an action once per key and caches the result.

func (*Cache) Clear added in go1.13

func (c *Cache) Clear()

Clear removes all entries in the cache.

Concurrent calls to Get may return old values. Concurrent calls to Do may return old values or store results in entries that have been deleted.

TODO(jayconrod): Delete this after the package cache clearing functions in internal/load have been removed.

func (*Cache) Delete added in go1.13

func (c *Cache) Delete(key interface{})

Delete removes an entry from the map. It is safe to call Delete for an entry that does not exist. Delete will return quickly, even if the result for a key is still being computed; the computation will finish, but the result won't be accessible through the cache.

TODO(jayconrod): Delete this after the package cache clearing functions in internal/load have been removed.

func (*Cache) DeleteIf added in go1.13

func (c *Cache) DeleteIf(pred func(key interface{}) bool)

DeleteIf calls pred for each key in the map. If pred returns true for a key, DeleteIf removes the corresponding entry. If the result for a key is still being computed, DeleteIf will remove the entry without waiting for the computation to finish. The result won't be accessible through the cache.

TODO(jayconrod): Delete this after the package cache clearing functions in internal/load have been removed.

func (*Cache) Do

func (c *Cache) Do(key interface{}, f func() interface{}) interface{}

Do calls the function f if and only if Do is being called for the first time with this key. No call to Do with a given key returns until the one call to f returns. Do returns the value returned by the one call to f.

func (*Cache) Get

func (c *Cache) Get(key interface{}) interface{}

Get returns the cached result associated with key. It returns nil if there is no such result. If the result for key is being computed, Get does not wait for the computation to finish.

type Queue added in go1.16

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

Queue manages a set of work items to be executed in parallel. The number of active work items is limited, and excess items are queued sequentially.

func NewQueue added in go1.16

func NewQueue(maxActive int) *Queue

NewQueue returns a Queue that executes up to maxActive items in parallel.

maxActive must be positive.

func (*Queue) Add added in go1.16

func (q *Queue) Add(f func())

Add adds f as a work item in the queue.

Add returns immediately, but the queue will be marked as non-idle until after f (and any subsequently-added work) has completed.

func (*Queue) Idle added in go1.16

func (q *Queue) Idle() <-chan struct{}

Idle returns a channel that will be closed when q has no (active or enqueued) work outstanding.

type Work

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

Work manages a set of work items to be executed in parallel, at most once each. The items in the set must all be valid map keys.

func (*Work) Add

func (w *Work) Add(item interface{})

Add adds item to the work set, if it hasn't already been added.

func (*Work) Do

func (w *Work) Do(n int, f func(item interface{}))

Do runs f in parallel on items from the work set, with at most n invocations of f running at a time. It returns when everything added to the work set has been processed. At least one item should have been added to the work set before calling Do (or else Do returns immediately), but it is allowed for f(item) to add new items to the set. Do should only be used once on a given Work.

Source Files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to