Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/rakyll/coop
Cheat sheet for some of the common concurrent flows in Go
https://github.com/rakyll/coop
Last synced: about 1 month ago
JSON representation
Cheat sheet for some of the common concurrent flows in Go
- Host: GitHub
- URL: https://github.com/rakyll/coop
- Owner: rakyll
- Archived: true
- Created: 2014-01-16T13:37:46.000Z (almost 11 years ago)
- Default Branch: master
- Last Pushed: 2015-10-06T15:47:03.000Z (about 9 years ago)
- Last Synced: 2024-09-21T17:04:55.797Z (about 2 months ago)
- Language: Go
- Homepage:
- Size: 229 KB
- Stars: 1,208
- Watchers: 35
- Forks: 46
- Open Issues: 5
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
- awesome-github-repos - rakyll/coop - Cheat sheet for some of the common concurrent flows in Go (Go)
- awesome-cheatsheet - Cheat sheet for some of the common concurrent flows in Go
README
# coop
[](https://travis-ci.org/rakyll/coop)
Note: This package became obsolete. I started it when I was learning Go a couple of years ago. I see so many better ways to implement them all now, so don't keep using this package as an ultimate reference.
coop contains some of the most common concurrent program flows I personally use in Go. I'm suggesting you to use this package as a snippets reference/cheat sheet instead of a library. The functionally provided in this package can be obtained in many different ways, and frankly with more performant implementations depending on the type of your problem.
coop contains implementations for the following flows:
### coop.At(time, fn)
Runs fn at t, returns a boolean channel that will receive a message after fn returns. The following example, prints "Hello World" in a minute and blocks the goroutine its running in until fn is completed.
~~~ go
done := coop.At(time.Now().Add(time.Minute), func() {
fmt.Println("Hello world")
})
<-done // wait for fn to be done
~~~
### coop.Until(time, duration, fn)
Runs fn once in every provided duration until t, returns a boolean channel that will receive a message after fn returns. The following example prints "Hello world" every minute until tomorrow, and blocks the goroutine its running in until the job is completed.
~~~ go
done := coop.Until(time.Now().Add(24*time.Hour), time.Minute, func() {
fmt.Println("Hello world")
})
<-done
~~~
### coop.After(duration, fn)
Runs fn after duration, returns a boolean channel that will receive a message after fn returns. The following example prints "Hello world" after a second and blocks until fn is completed.
~~~ go
done := coop.After(time.Second, func() {
fmt.Println("Hello world")
})
<-done
~~~
### coop.Every(duration, fn)
Runs fn once in every duration, and never stops. The following example will print "Hello World" once in every second.
~~~ go
coop.Every(time.Second, func() {
fmt.Println("Hello world")
})
~~~
### coop.Timeout(duration, fn)
Runs fn, and cancels the running job if timeout is exceeded. The following example will timeout and fn will return immediately ("Hello world will not printed"), the value read from the done channel will be false if timeout occurs, true if fn is completed.
~~~ go
done := coop.Timeout(time.Second, func() {
time.Sleep(time.Hour)
fmt.Println("Hello world")
})
<-done // will return false, because timeout occurred
~~~
### coop.All(fns...)
Runs the list of fns concurrently, returns a boolean channel that will receive a message after all of the fns are completed. The following example will start 4 printing jobs concurrently and wait until all of them are completed.
~~~ go
printFn := func() {
fmt.Println("Hello world")
}
<-coop.All(printFn, printFn, printFn, printFn)
~~~
### coop.AllWithThrottle(num, fns...)
Similar to coop.All, but with limiting. Runs the list of fns concurrently, but at most num fns at a time. Returns a boolean channel that will receive a message after all of the fns are completed. The following example will start 3 printing jobs immediately, and run the left out one once the first 3 is completed. It will block the goroutine until all 4 are finished.
~~~ go
printFn := func() {
fmt.Println("Hello world")
}
<-coop.AllWithThrottle(3, printFn, printFn, printFn, printFn)
~~~
### coop.Replicate(n, fn)
Runs fn n time concurrently, returns a boolean channel that indicates all runs are completed. The following example prints "Hello world" 5 times, and waits for all printing jobs are finished.
~~~ go
<-coop.Replicate(5, func() {
fmt.Println("Hello world")
})
~~~
## License
Copyright 2014 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. 