refactoring examples
Vladimir Bauer
6 years ago
| 90 | 90 |
// simulating some work
|
| 91 | 91 |
go func() {
|
| 92 | 92 |
defer wg.Done()
|
|
93 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 93 | 94 |
max := 100 * time.Millisecond
|
| 94 | 95 |
for i := 0; i < total; i++ {
|
| 95 | 96 |
start := time.Now()
|
| 96 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
97 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 97 | 98 |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 98 | 99 |
bar.Increment(time.Since(start))
|
| 99 | 100 |
}
|
| 9 | 9 |
"github.com/vbauerster/mpb/v4"
|
| 10 | 10 |
"github.com/vbauerster/mpb/v4/decor"
|
| 11 | 11 |
)
|
| 12 | |
|
| 13 | |
func init() {
|
| 14 | |
rand.Seed(time.Now().UnixNano())
|
| 15 | |
}
|
| 16 | 12 |
|
| 17 | 13 |
func main() {
|
| 18 | 14 |
var wg sync.WaitGroup
|
|
| 45 | 41 |
// simulating some work
|
| 46 | 42 |
go func() {
|
| 47 | 43 |
defer wg.Done()
|
|
44 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 48 | 45 |
max := 100 * time.Millisecond
|
| 49 | 46 |
for i := 0; i < total; i++ {
|
| 50 | 47 |
start := time.Now()
|
| 51 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
48 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 52 | 49 |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 53 | 50 |
bar.Increment(time.Since(start))
|
| 54 | 51 |
}
|
| 9 | 9 |
"github.com/vbauerster/mpb/v4"
|
| 10 | 10 |
"github.com/vbauerster/mpb/v4/decor"
|
| 11 | 11 |
)
|
| 12 | |
|
| 13 | |
func init() {
|
| 14 | |
rand.Seed(time.Now().UnixNano())
|
| 15 | |
}
|
| 16 | 12 |
|
| 17 | 13 |
func main() {
|
| 18 | 14 |
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
| 39 | 35 |
|
| 40 | 36 |
go func() {
|
| 41 | 37 |
defer wg.Done()
|
|
38 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 42 | 39 |
max := 100 * time.Millisecond
|
| 43 | 40 |
for !bar.Completed() {
|
| 44 | 41 |
start := time.Now()
|
| 45 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
42 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 46 | 43 |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 47 | 44 |
bar.Increment(time.Since(start))
|
| 48 | 45 |
}
|
| 8 | 8 |
"github.com/vbauerster/mpb/v4"
|
| 9 | 9 |
"github.com/vbauerster/mpb/v4/decor"
|
| 10 | 10 |
)
|
| 11 | |
|
| 12 | |
func init() {
|
| 13 | |
rand.Seed(time.Now().UnixNano())
|
| 14 | |
}
|
| 15 | 11 |
|
| 16 | 12 |
func main() {
|
| 17 | 13 |
var wg sync.WaitGroup
|
|
| 45 | 41 |
// simulating some work
|
| 46 | 42 |
go func() {
|
| 47 | 43 |
defer wg.Done()
|
|
44 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 48 | 45 |
max := 100 * time.Millisecond
|
| 49 | 46 |
for i := 0; i < total; i++ {
|
| 50 | 47 |
start := time.Now()
|
| 51 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
48 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 52 | 49 |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 53 | 50 |
bar.Increment(time.Since(start))
|
| 54 | 51 |
}
|
| 8 | 8 |
"github.com/vbauerster/mpb/v4"
|
| 9 | 9 |
"github.com/vbauerster/mpb/v4/decor"
|
| 10 | 10 |
)
|
| 11 | |
|
| 12 | |
func init() {
|
| 13 | |
rand.Seed(time.Now().UnixNano())
|
| 14 | |
}
|
| 15 | 11 |
|
| 16 | 12 |
func main() {
|
| 17 | 13 |
var wg sync.WaitGroup
|
|
| 46 | 42 |
// simulating some work
|
| 47 | 43 |
go func() {
|
| 48 | 44 |
defer wg.Done()
|
|
45 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 49 | 46 |
max := 100 * time.Millisecond
|
| 50 | 47 |
for i := 0; i < total; i++ {
|
| 51 | 48 |
start := time.Now()
|
| 52 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
49 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 53 | 50 |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 54 | 51 |
bar.Increment(time.Since(start))
|
| 55 | 52 |
}
|
| 8 | 8 |
"github.com/vbauerster/mpb/v4"
|
| 9 | 9 |
"github.com/vbauerster/mpb/v4/decor"
|
| 10 | 10 |
)
|
| 11 | |
|
| 12 | |
func init() {
|
| 13 | |
rand.Seed(time.Now().UnixNano())
|
| 14 | |
}
|
| 15 | 11 |
|
| 16 | 12 |
func main() {
|
| 17 | 13 |
var wg sync.WaitGroup
|
|
| 40 | 36 |
// simulating some work
|
| 41 | 37 |
go func() {
|
| 42 | 38 |
defer wg.Done()
|
|
39 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 43 | 40 |
max := 100 * time.Millisecond
|
| 44 | 41 |
for i := 0; i < total; i++ {
|
| 45 | 42 |
start := time.Now()
|
| 46 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
43 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 47 | 44 |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 48 | 45 |
bar.Increment(time.Since(start))
|
| 49 | 46 |
}
|
| 11 | 11 |
)
|
| 12 | 12 |
|
| 13 | 13 |
func main() {
|
| 14 | |
rand.Seed(time.Now().UnixNano())
|
| 15 | 14 |
p := mpb.New(mpb.PopCompletedMode())
|
| 16 | 15 |
|
| 17 | 16 |
total, numBars := 100, 2
|
|
| 31 | 30 |
)
|
| 32 | 31 |
// simulating some work
|
| 33 | 32 |
go func() {
|
|
33 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 34 | 34 |
max := 100 * time.Millisecond
|
| 35 | 35 |
for i := 0; i < total; i++ {
|
| 36 | 36 |
start := time.Now()
|
| 37 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
37 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 38 | 38 |
bar.Increment(time.Since(start))
|
| 39 | 39 |
}
|
| 40 | 40 |
}()
|
|
| 44 | 44 |
wg.Add(1)
|
| 45 | 45 |
go func() {
|
| 46 | 46 |
defer wg.Done()
|
|
47 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 47 | 48 |
max := 3000 * time.Millisecond
|
| 48 | 49 |
for i := 0; i < 10; i++ {
|
| 49 | 50 |
p.Add(0, makeLogBar(fmt.Sprintf("some log: %d", i))).SetTotal(0, true)
|
| 50 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
51 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 51 | 52 |
}
|
| 52 | 53 |
}()
|
| 53 | 54 |
|
| 13 | 13 |
var quietMode bool
|
| 14 | 14 |
|
| 15 | 15 |
func init() {
|
| 16 | |
rand.Seed(time.Now().UnixNano())
|
| 17 | 16 |
flag.BoolVar(&quietMode, "q", false, "quiet mode")
|
| 18 | 17 |
}
|
| 19 | 18 |
|
|
| 55 | 54 |
// simulating some work
|
| 56 | 55 |
go func() {
|
| 57 | 56 |
defer wg.Done()
|
|
57 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 58 | 58 |
max := 100 * time.Millisecond
|
| 59 | 59 |
for i := 0; i < total; i++ {
|
| 60 | 60 |
start := time.Now()
|
| 61 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
61 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 62 | 62 |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 63 | 63 |
bar.Increment(time.Since(start))
|
| 64 | 64 |
}
|
| 8 | 8 |
"github.com/vbauerster/mpb/v4"
|
| 9 | 9 |
"github.com/vbauerster/mpb/v4/decor"
|
| 10 | 10 |
)
|
| 11 | |
|
| 12 | |
func init() {
|
| 13 | |
rand.Seed(time.Now().UnixNano())
|
| 14 | |
}
|
| 15 | 11 |
|
| 16 | 12 |
func main() {
|
| 17 | 13 |
var wg sync.WaitGroup
|
|
| 32 | 28 |
)
|
| 33 | 29 |
go func() {
|
| 34 | 30 |
defer wg.Done()
|
|
31 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 35 | 32 |
max := 100 * time.Millisecond
|
| 36 | 33 |
for i := 0; !b.Completed(); i++ {
|
| 37 | 34 |
start := time.Now()
|
|
| 39 | 36 |
// aborting and removing while bar is running
|
| 40 | 37 |
b.Abort(true)
|
| 41 | 38 |
}
|
| 42 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
39 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 43 | 40 |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 44 | 41 |
b.Increment(time.Since(start))
|
| 45 | 42 |
}
|
| 8 | 8 |
"github.com/vbauerster/mpb/v4"
|
| 9 | 9 |
"github.com/vbauerster/mpb/v4/decor"
|
| 10 | 10 |
)
|
| 11 | |
|
| 12 | |
func init() {
|
| 13 | |
rand.Seed(time.Now().UnixNano())
|
| 14 | |
}
|
| 15 | 11 |
|
| 16 | 12 |
func main() {
|
| 17 | 13 |
var wg sync.WaitGroup
|
|
| 43 | 39 |
// simulating some work
|
| 44 | 40 |
go func() {
|
| 45 | 41 |
defer wg.Done()
|
|
42 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 46 | 43 |
max := 100 * time.Millisecond
|
| 47 | 44 |
for i := 0; i < total; i++ {
|
| 48 | 45 |
start := time.Now()
|
| 49 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
46 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 50 | 47 |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 51 | 48 |
bar.Increment(time.Since(start))
|
| 52 | 49 |
}
|
| 0 | |
module github.com/vbauerster/mpb/_examples/sortBars
|
| 1 | |
|
| 2 | |
go 1.13
|
| 3 | |
|
| 4 | |
require github.com/vbauerster/mpb/v4 v4.9.3
|
| 0 | |
package main
|
| 1 | |
|
| 2 | |
import (
|
| 3 | |
"fmt"
|
| 4 | |
"math/rand"
|
| 5 | |
"sync"
|
| 6 | |
"time"
|
| 7 | |
|
| 8 | |
"github.com/vbauerster/mpb/v4"
|
| 9 | |
"github.com/vbauerster/mpb/v4/decor"
|
| 10 | |
)
|
| 11 | |
|
| 12 | |
func init() {
|
| 13 | |
rand.Seed(time.Now().UnixNano())
|
| 14 | |
}
|
| 15 | |
|
| 16 | |
func main() {
|
| 17 | |
var wg sync.WaitGroup
|
| 18 | |
p := mpb.New(mpb.WithWaitGroup(&wg))
|
| 19 | |
total := 100
|
| 20 | |
numBars := 3
|
| 21 | |
wg.Add(numBars)
|
| 22 | |
|
| 23 | |
for i := 0; i < numBars; i++ {
|
| 24 | |
name := fmt.Sprintf("Bar#%d:", i)
|
| 25 | |
b := p.AddBar(int64(total),
|
| 26 | |
mpb.BarOptOnCond(mpb.BarWidth(40), func() bool { return i > 0 }),
|
| 27 | |
mpb.PrependDecorators(
|
| 28 | |
decor.Name(name, decor.WCSyncWidth),
|
| 29 | |
decor.CountersNoUnit("%d / %d", decor.WCSyncSpace),
|
| 30 | |
),
|
| 31 | |
mpb.AppendDecorators(
|
| 32 | |
decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WC{W: 3}),
|
| 33 | |
),
|
| 34 | |
)
|
| 35 | |
go func() {
|
| 36 | |
defer wg.Done()
|
| 37 | |
max := 100 * time.Millisecond
|
| 38 | |
for i := 0; i < total; i++ {
|
| 39 | |
start := time.Now()
|
| 40 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
| 41 | |
if i&1 == 1 {
|
| 42 | |
priority := total - int(b.Current())
|
| 43 | |
b.SetPriority(priority)
|
| 44 | |
}
|
| 45 | |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 46 | |
b.Increment(time.Since(start))
|
| 47 | |
}
|
| 48 | |
}()
|
| 49 | |
}
|
| 50 | |
|
| 51 | |
p.Wait()
|
| 52 | |
}
|
| 8 | 8 |
"github.com/vbauerster/mpb/v4"
|
| 9 | 9 |
"github.com/vbauerster/mpb/v4/decor"
|
| 10 | 10 |
)
|
| 11 | |
|
| 12 | |
func init() {
|
| 13 | |
rand.Seed(time.Now().UnixNano())
|
| 14 | |
}
|
| 15 | 11 |
|
| 16 | 12 |
func main() {
|
| 17 | 13 |
var wg sync.WaitGroup
|
|
| 62 | 58 |
// simulating some work
|
| 63 | 59 |
go func() {
|
| 64 | 60 |
defer wg.Done()
|
|
61 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 65 | 62 |
max := 100 * time.Millisecond
|
| 66 | 63 |
for i := 0; i < total; i++ {
|
| 67 | 64 |
start := time.Now()
|
| 68 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
65 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 69 | 66 |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 70 | 67 |
bar.Increment(time.Since(start))
|
| 71 | 68 |
}
|
| 8 | 8 |
"github.com/vbauerster/mpb/v4"
|
| 9 | 9 |
"github.com/vbauerster/mpb/v4/decor"
|
| 10 | 10 |
)
|
| 11 | |
|
| 12 | |
func init() {
|
| 13 | |
rand.Seed(time.Now().UnixNano())
|
| 14 | |
}
|
| 15 | 11 |
|
| 16 | 12 |
func main() {
|
| 17 | 13 |
var wg sync.WaitGroup
|
|
| 39 | 35 |
// simulating some work
|
| 40 | 36 |
go func() {
|
| 41 | 37 |
defer wg.Done()
|
|
38 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 42 | 39 |
max := 100 * time.Millisecond
|
| 43 | 40 |
for i := 0; i < total; i++ {
|
| 44 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
41 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 45 | 42 |
bar.Increment()
|
| 46 | 43 |
}
|
| 47 | 44 |
}()
|
| 12 | 12 |
const (
|
| 13 | 13 |
totalBars = 32
|
| 14 | 14 |
)
|
| 15 | |
|
| 16 | |
func init() {
|
| 17 | |
rand.Seed(time.Now().UnixNano())
|
| 18 | |
}
|
| 19 | 15 |
|
| 20 | 16 |
func main() {
|
| 21 | 17 |
var wg sync.WaitGroup
|
|
| 42 | 38 |
|
| 43 | 39 |
go func() {
|
| 44 | 40 |
defer wg.Done()
|
|
41 |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 45 | 42 |
max := 100 * time.Millisecond
|
| 46 | 43 |
for !bar.Completed() {
|
| 47 | |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
|
44 |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
| 48 | 45 |
bar.Increment()
|
| 49 | 46 |
}
|
| 50 | 47 |
}()
|
| 32 | 32 |
mpb.AppendDecorators(decor.Percentage()),
|
| 33 | 33 |
)
|
| 34 | 34 |
// simulating some work
|
| 35 | |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 36 | 35 |
max := 100 * time.Millisecond
|
| 37 | 36 |
for i := 0; i < total; i++ {
|
| 38 | 37 |
start := time.Now()
|
| 39 | |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
|
38 |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
| 40 | 39 |
// since ewma decorator is used, we need to pass time.Since(start)
|
| 41 | 40 |
bar.Increment(time.Since(start))
|
| 42 | 41 |
}
|
|
| 48 | 47 |
p := mpb.New()
|
| 49 | 48 |
bar := p.AddBar(100)
|
| 50 | 49 |
|
| 51 | |
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
| 52 | 50 |
max := 100 * time.Millisecond
|
| 53 | 51 |
for !bar.Completed() {
|
| 54 | |
time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
|
|
52 |
time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
|
| 55 | 53 |
bar.Increment()
|
| 56 | 54 |
}
|
| 57 | 55 |
|