Leetcode的并发题
Leetcode的并发题。这道题是这么说的:
编写一个可以从 1 到 n 输出代表这个数字的字符串的程序，但是：
如果这个数字可以被 3 整除，输出 "fizz"。
如果这个数字可以被 5 整除，输出 "buzz"。
如果这个数字可以同时被 3 和 5 整除，输出 "fizzbuzz"。
例如，当 n = 15，输出： 1, 2, fizz, 4, buzz, fizz, 7, 8, fizz, buzz, 11, fizz, 13, 14, fizzbuzz。
假设有这么一个类：
class FizzBuzz {
public FizzBuzz(int n) { ... } // constructor
public void fizz(printFizz) { ... } // only output "fizz"
public void buzz(printBuzz) { ... } // only output "buzz"
public void fizzbuzz(printFizzBuzz) { ... } // only output "fizzbuzz"
public void number(printNumber) { ... } // only output the numbers
}
请你实现一个有四个线程的多线程版 FizzBuzz， 同一个 FizzBuzz 实例会被如下四个线程使用：
线程A将调用 fizz() 来判断是否能被 3 整除，如果可以，则输出 fizz。
线程B将调用 buzz() 来判断是否能被 5 整除，如果可以，则输出 buzz。
线程C将调用 fizzbuzz() 来判断是否同时能被 3 和 5 整除，如果可以，则输出 fizzbuzz。
线程D将调用 number() 来实现输出既不能被 3 整除也不能被 5 整除的数字。
基本上，这是一个任务编排的并发题，其实使用最简单的并发原语就可以实现。
链接
package main
import (
"fmt"
"sync"
)
type FizzBuzz2 struct {
n int
ch chan int
wg sync.WaitGroup
}
func New2(n int) *FizzBuzz2 {
return &FizzBuzz2{
n: n,
ch: make(chan int, 1),
}
}
func (fb *FizzBuzz2) start() {
fb.wg.Add(4)
go fb.fizz()
go fb.buzz()
go fb.FizzBuzz2()
go fb.number()
fb.ch <- 1
fb.wg.Wait()
}
func (fb *FizzBuzz2) fizz() {
defer fb.wg.Done()
for v := range fb.ch {
if v > fb.n {
fb.ch <- v
return
}
if v%3 == 0 {
if v%5 == 0 {
fb.ch <- v
continue
}
if v == fb.n {
fmt.Print(" fizz。")
} else {
fmt.Print(" fizz,")
}
fb.ch <- v + 1
continue
}
fb.ch <- v
}
}
func (fb *FizzBuzz2) buzz() {
defer fb.wg.Done()
for v := range fb.ch {
if v > fb.n {
fb.ch <- v
return
}
if v%5 == 0 {
if v%3 == 0 {
fb.ch <- v
continue
}
if v == fb.n {
fmt.Print(" buzz。")
} else {
fmt.Print(" buzz,")
}
fb.ch <- v + 1
continue
}
fb.ch <- v
}
}
func (fb *FizzBuzz2) FizzBuzz2() {
defer fb.wg.Done()
for v := range fb.ch {
if v > fb.n {
fb.ch <- v
return
}
if v%5 == 0 && v%3 == 0 {
if v == fb.n {
fmt.Print(" FizzBuzz2。")
} else {
fmt.Print(" FizzBuzz2,")
}
fb.ch <- v + 1
continue
}
fb.ch <- v
}
}
func (fb *FizzBuzz2) number() {
defer fb.wg.Done()
for v := range fb.ch {
if v > fb.n {
fb.ch <- v
return
}
if v%5 != 0 && v%3 != 0 {
if v == fb.n {
fmt.Printf(" %d。", v)
} else {
fmt.Printf(" %d,", v)
}
fb.ch <- v + 1
continue
}
fb.ch <- v
}
}
func main1() {
fb := New2(15)
fb.start()
}
/**
这里有一个知识点： 会不会总是只有一个goroutine把值取出来放回去，取出来放回去，别的goroutine没有机会读取到这个值呢？
不会的，根据channel的实现，waiter还是有先来后到之说的，某个goroutine总是能有机会取到自己要处理的数据。
*/
cyclicbarrier 参考java的 含义
package main
import (
"context"
"fmt"
"sync"
"github.com/marusama/cyclicbarrier"
)
// 编写一个可以从 1 到 n 输出代表这个数字的字符串的程序，要求：
// 如果这个数字可以被 3 整除，输出 "fizz"。
// 如果这个数字可以被 5 整除，输出 "buzz"。
// 如果这个数字可以同时被 3 和 5 整除，输出 "fizzbuzz"。
// 例如，当 n = 15，输出： 1, 2, fizz, 4, buzz, fizz, 7, 8, fizz, buzz, 11, fizz, 13, 14, fizzbuzz。
// 假设有这么一个结构体：
// type FizzBuzz3 struct {}
// func (fb *FizzBuzz3) fizz() {}
// func (fb *FizzBuzz3) buzz() {}
// func (fb *FizzBuzz3) fizzbuzz() {}
// func (fb *FizzBuzz3) number() {}
// 请你实现一个有四个线程的多协程版 FizzBuzz3，同一个 FizzBuzz3 对象会被如下四个协程使用：
// 协程A将调用 fizz() 来判断是否能被 3 整除，如果可以，则输出 fizz。
// 协程B将调用 buzz() 来判断是否能被 5 整除，如果可以，则输出 buzz。
// 协程C将调用 fizzbuzz() 来判断是否同时能被 3 和 5 整除，如果可以，则输出 fizzbuzz。
// 协程D将调用 number() 来实现输出既不能被 3 整除也不能被 5 整除的数字。
type FizzBuzz3 struct {
n int
barrier cyclicbarrier.CyclicBarrier
wg sync.WaitGroup
}
func New3(n int) *FizzBuzz3 {
return &FizzBuzz3{
n: n,
barrier: cyclicbarrier.New(4),
}
}
func (fb *FizzBuzz3) start() {
fb.wg.Add(4)
go fb.fizz()
go fb.buzz()
go fb.fizzbuzz()
go fb.number()
fb.wg.Wait()
}
func (fb *FizzBuzz3) fizz() {
defer fb.wg.Done()
ctx := context.Background()
v := 0
for {
fb.barrier.Await(ctx) // ..and wait for other parties on the barrier.
// Last arrived goroutine will do the barrier action
// and then pass all other goroutines to the next round
v++
if v > fb.n {
return
}
if v%3 == 0 {
if v%5 == 0 {
continue
}
if v == fb.n {
fmt.Print(" fizz。")
} else {
fmt.Print(" fizz,")
}
}
}
}
func (fb *FizzBuzz3) buzz() {
defer fb.wg.Done()
ctx := context.Background()
v := 0
for {
fb.barrier.Await(ctx)
v++
if v > fb.n {
return
}
if v%5 == 0 {
if v%3 == 0 {
continue
}
if v == fb.n {
fmt.Print(" buzz。")
} else {
fmt.Print(" buzz,")
}
}
}
}
func (fb *FizzBuzz3) fizzbuzz() {
defer fb.wg.Done()
ctx := context.Background()
v := 0
for {
fb.barrier.Await(ctx)
v++
if v > fb.n {
return
}
if v%5 == 0 && v%3 == 0 {
if v == fb.n {
fmt.Print(" fizzbuzz。")
} else {
fmt.Print(" fizzbuzz,")
}
}
}
}
func (fb *FizzBuzz3) number() {
defer fb.wg.Done()
ctx := context.Background()
v := 0
for {
fb.barrier.Await(ctx)
v++
if v > fb.n {
return
}
if v%5 != 0 && v%3 != 0 {
if v == fb.n {
fmt.Printf(" %d。", v)
} else {
fmt.Printf(" %d,", v)
}
}
}
}
func main() {
fb := New3(15)
fb.start()
}