啊哈，一道有趣的Go并发题

最新推荐文章于 2023-04-20 18:07:17 发布
最新推荐文章于 2023-04-20 18:07:17 发布
阅读量406 收藏
点赞数
分类专栏： 编程 Java 程序员 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73257876/article/details/126674085
版权
程序员 同时被 3 个专栏收录
311 篇文章 3 订阅
订阅专栏
编程
265 篇文章 3 订阅
订阅专栏
Java
247 篇文章 2 订阅
订阅专栏

今天一位同学给我出了一道并发题，作为在极客时间开了《GO并发编程实战课》的作者，居然一时间没有回答上来，惭愧啊，所以晚上专门研究了一下题目，给出几个实现方案供探讨。

这道题貌似在哪里见过，凭借回忆我找到了，原来是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 整除的数字。

基本上，这是一个任务编排的并发题，其实使用最简单的并发原语就可以实现。

将并发转为串行

我开始的思路想错了，我想实现一个manager，去调度四个goroutine,但是其实有一个最简单的糙快猛的方法，就像我在专栏中出的"击鼓传花”那道题一样，可以将这四个goroutine串行化。

每一个数字，交给一个goroutine去处理，如果不是它负责处理，那么它就交给下一个goroutine。

这道题的妙处就在于，这四种case是没有交叉的，一个数字只能由一个goroutine处理，并且肯定会有一个goroutine去处理，这就好办了。在四个goroutine交递的过程中，肯定有一个goroutine会输出内容，如果它输出了内容，它就将数字加一，交给下一个groutine去检查和处理，这就开启了新的一轮数字的检查和处理。

当处理的数字大于指定的数字，它将数字交递给下一个goroutine,然后返回。这样下一个goroutine同样的处理也会返回。最后四个goroutine都返回了。

我们使用一个WaitGroup等待四个goroutine都返回，然后程序退出。

代码如下：

package main

import (
	"fmt"
	"sync"
)

type FizzBuzz struct {
	n int

	chs []chan int
	wg  sync.WaitGroup
}

func New(n int) *FizzBuzz {
	chs := make([]chan int,4)
	for i :=0; i <4; i++ {
		chs[i] = make(chan int,1)
	}

	return &FizzBuzz{
		n:   n,
		chs: chs,
	}
}

func (fb *FizzBuzz) start() {
	fb.wg.Add(4)

	go fb.fizz()
	go fb.buzz()
	go fb.fizzbuzz()
	go fb.number()

	fb.chs[0] <-1

	fb.wg.Wait()
}

func (fb *FizzBuzz) fizz() {
	defer fb.wg.Done()

	next := fb.chs[1]
	for v := range fb.chs[0] {
		if v > fb.n {
			next <- v
			return
		}

		if v%3 ==0 {
			if v%5 ==0 {
				next <- v
				continue
			}

			if v == fb.n {
				fmt.Print(" fizz。")
			} else {
				fmt.Print(" fizz,")
			}

			next <- v +1
			continue
		}

		next <- v
	}

}
func (fb *FizzBuzz) buzz() {
	defer fb.wg.Done()

	next := fb.chs[2]
	for v := range fb.chs[1] {

		if v > fb.n {
			next <- v
			return
		}

		if v%5 ==0 {
			if v%3 ==0 {
				next <- v
				continue
			}

			if v == fb.n {
				fmt.Print(" buzz。")
			} else {
				fmt.Print(" buzz,")
			}

			next <- v +1
			continue
		}

		next <- v
	}
}
func (fb *FizzBuzz) fizzbuzz() {
	defer fb.wg.Done()

	next := fb.chs[3]
	for v := range fb.chs[2] {

		if v > fb.n {
			next <- v
			return
		}

		if v%5 ==0 && v%3 ==0 {
			if v == fb.n {
				fmt.Print(" fizzbuzz。")
			} else {
				fmt.Print(" fizzbuzz,")
			}

			next <- v +1
			continue
		}

		next <- v
	}
}
func (fb *FizzBuzz) number() {
	defer fb.wg.Done()

	next := fb.chs[0]
	for v := range fb.chs[3] {

		if v > fb.n {
			next <- v
			return
		}

		if v%5 !=0 && v%3 !=0 {
			if v == fb.n {
				fmt.Printf(" %d。", v)
			} else {
				fmt.Printf(" %d,", v)
			}

			next <- v +1
			continue
		}

		next <- v

	}
}

func main() {
	fb := New(15)
	fb.start()
}

使用一个channel

上面讲并发转为串行的操作，总是让人感觉差强人意，我们更想并发的去执行。

所以可以转换一下思路，四个goroutine使用同一个channel。 如果某个goroutine非常幸运，从这个channel中取出一个值，它会做检查，无非两种情况：

  • 正好是自己要处理的数： 它输出相应的文本，并且把值加一，再放入到channel中
  • 不是自己要处理的数：把此数再放回到channel中

对于每一个数，总会有goroutine取出来并处理。

当取出来的数大于指定的数时，把此数放回到channel，并返回。

代码如下：

package main

import (
	"fmt"
	"sync"
)

type FizzBuzz struct {
	n int

	ch chan int
	wg sync.WaitGroup
}

func New(n int) *FizzBuzz {
	return &FizzBuzz{
		n:  n,
		ch: make(chan int,1),
	}
}

func (fb *FizzBuzz) start() {
	fb.wg.Add(4)

	go fb.fizz()
	go fb.buzz()
	go fb.fizzbuzz()
	go fb.number()

	fb.ch <-1

	fb.wg.Wait()
}

func (fb *FizzBuzz) 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 *FizzBuzz) 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 *FizzBuzz) fizzbuzz() {
	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(" fizzbuzz。")
			} else {
				fmt.Print(" fizzbuzz,")
			}

			fb.ch <- v +1
			continue
		}

		fb.ch <- v
	}
}
func (fb *FizzBuzz) 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 main() {
	fb := New(15)
	fb.start()
}

这里有一个知识点： 会不会总是只有一个goroutine把值取出来放回去，取出来放回去，别的goroutine没有机会读取到这个值呢？

不会的，根据channel的实现，waiter还是有先来后到之说的，某个goroutine总是能有机会取到自己要处理的数据。

使用栅栏

其实我一直想实现的是使用 cyclicbarrier ，可能有些同学不熟悉这个并发原语，但是针对这个场景，使用Barrier代码就非常的简洁，逻辑非常的明了。

而且循环栅栏更适合这歌场景，因为我们要重复使用栅栏。

针对每一个数字，我们都设置了栅栏，让每一个goroutine都去检查和处理，四个goroutine中总会有一个会处理这个数字。处理完这个数字之后，把数字加一，等待下一次栅栏放行。

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 FizzBuzz struct {}
// func (fb *FizzBuzz) fizz() {}
// func (fb *FizzBuzz) buzz() {}
// func (fb *FizzBuzz) fizzbuzz() {}
// func (fb *FizzBuzz) number() {}

// 请你实现一个有四个线程的多协程版 FizzBuzz，同一个 FizzBuzz 对象会被如下四个协程使用：

// 协程A将调用 fizz() 来判断是否能被 3 整除，如果可以，则输出 fizz。
// 协程B将调用 buzz() 来判断是否能被 5 整除，如果可以，则输出 buzz。
// 协程C将调用 fizzbuzz() 来判断是否同时能被 3 和 5 整除，如果可以，则输出 fizzbuzz。
// 协程D将调用 number() 来实现输出既不能被 3 整除也不能被 5 整除的数字。

type FizzBuzz struct {
	n int

	v       int
	barrier cyclicbarrier.CyclicBarrier
	wg      sync.WaitGroup
}

func New(n int) *FizzBuzz {
	return &FizzBuzz{
		n:       n,
		barrier: cyclicbarrier.New(4),
	}
}

func (fb *FizzBuzz) start() {
	fb.wg.Add(4)

	go fb.fizz()
	go fb.buzz()
	go fb.fizzbuzz()
	go fb.number()

	fb.v++

	fb.wg.Wait()
}

func (fb *FizzBuzz) fizz() {
	defer fb.wg.Done()

	ctx := context.Background()
	for {
		fb.barrier.Await(ctx)

		v := fb.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,")
			}

			fb.v++
		}

	}

}
func (fb *FizzBuzz) buzz() {
	defer fb.wg.Done()

	ctx := context.Background()
	for {
		fb.barrier.Await(ctx)

		v := fb.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,")
			}

			fb.v++
		}
	}
}
func (fb *FizzBuzz) fizzbuzz() {
	defer fb.wg.Done()

	ctx := context.Background()
	for {
		fb.barrier.Await(ctx)

		v := fb.v

		if v > fb.n {
			return
		}

		if v%5 ==0 && v%3 ==0 {
			if v == fb.n {
				fmt.Print(" fizzbuzz。")
			} else {
				fmt.Print(" fizzbuzz,")
			}

			fb.v++
			continue
		}
	}
}
func (fb *FizzBuzz) number() {
	defer fb.wg.Done()

	ctx := context.Background()
	for {
		fb.barrier.Await(ctx)

		v := fb.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)
			}

			fb.v++
			continue
		}

	}
}

func main() {
	fb := New(15)
	fb.start()
}

使用其它并发原语

我还想到了 sync.Cond 、 Semaphore 、 WaitGroup 等并发原语，

简单

评估之后，我感觉使用这几个并发原语做任务编排不太合适。

sync.Cond
Semaphore
WaitGroup

所以这三个并发原语我尝试之后放弃了。我个人还是比较喜欢Barrier的实现方式，虽然它有一个“惊群”的缺点，但是对于这道题而言问题不大。

你有什么想法和实现，欢迎在原文链接的评论区留言。

七包辣条
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
阿里的一道Java并发面试题详解
08-25
主要介绍了阿里的一道Java并发面试题详解,网络、并发相关的知识，相对其他一些编程知识点更难一些，主要是不好调试并且涉及内容太多 ！,需要的朋友可以参考下
golang--好用的第三方库1
eye2cro
05-26 768
好用的golang库1 (信号量、单飞、信号栅栏、分组操作、分布式锁) 1 信号量 golang.org/x/sync ：使用互斥锁 +List 实现的。互斥锁实现其它字段的保护，而 List 实现了一个等待队列，等待者的通知是通过 Channel 的通知机制实现的。 https://github.com/marusama/semaphore ：可以动态更改资源容量的信号量 2 单飞模式 https://pkg.go.dev/golang.org/x/sync/singleflight 合并读请求 3 信号
CyclicBarrier: 循环栅栏
qq_36059306的博客
06-26 375
针对场景 CyclicBarrier允许一组goroutine相互等待，直到所有goroutine都到达栅栏后，才能继续执行 因为CyclicBarrier是可复用的，所以叫做循环栅栏 CyclicBarrier和WaitGroup的选择： 如果是一组goroutine相互等待，然后一起继续执行，那么使用CyclicBarrier 如果是一个goroutine等待一组goroutine，那么使用WaitGroup 简单使用 CyclicBarrier有两个初始化方法： New：只需要一个参数，指定参与者
LeetCode编写一个可以从 1 到 n 输出代表这个数字的字符串的程序
JavaBigData的博客
09-20 640
题目 编写一个可以从 1 到 n 输出代表这个数字的字符串的程序，但是： 如果这个数字可以被 3 整除，输出 "fizz"。 如果这个数字可以被 5 整除，输出 "buzz"。 如果这个数字可以同时被 3 和 5 整除，输出 "fizzbuzz"。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/fizz-buzz-multithreaded 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 // // Created by
四个线程交替打印字符串
peony的博客
11-03 629
来源于leetcode1195 原题如下： 编写一个可以从 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 FizzB.
分享一个极好的go练手小项目，可以综合应用高并发服务的许多知识点。
ckw1988的专栏
04-20 288
客户端在发送请求前，注册一个随机名称的队列，用以接收计算结果的返回值（以下简称回应队列），该队列名会在发送计算请求到“rpc_queue”时附带在请求信息的“ReplyTo”属性中，而服务端在计算完毕后向该队列名发送计算结果即可。接下来找到客户端代码的fibonacciRPC方法的定义位置，该方法即rpc方法的本体，方法中包含了发送请求到rpc服务、阻塞线程以等待返回、获取返回结果后return给方法调用者等三个步骤，对外表现即为一个同步调用方法。我自己完成的demo再稍做修饰，过会儿上传。
【文件夹】Go语言并发之道.pdf
05-12
你将理解 Go语言为何选定这些并发模型，这些模型又会带来什么问题，以及你如何组合利用这些模型中的原语去解决问题。学习那些让你在独立且自信的编写与实现任何规模并发系统时所需要用到的技巧和工具。 理解Go语言...
Go语言中的并发问题研究
最新发布
04-14
了解 Go 的新并发原语和机制对千理解它们是如何影响并发Bugs 是至关重要的， 并发 Bugs 是很难调试的和被发现的，也是传统多线程编程语言中被最广泛研究的 Bugs 类型。 因为以前没有关于 Go 的并发 Bugs 的研究。 ...
Go语言并发之道
04-15
你将理解 Go语言为何选定这些并发模型，这些模型又会带来什么问题，以及你如何组合利用这些模型中的原语去解决问题。学习那些让你在独立且自信的编写与实现任何规模并发系统时所需要用到的技巧和工具。 理解Go语言...
并发题库 (含参考答案).md
02-02
52道java常用的并发面试题目，包含答案。
Go-解决Golang并发性练习
08-13
解决Golang并发性练习
LeetCode_多线程
sc179的博客
08-20 353
目录哲学家进餐1 题目描述2 解题（Java）交替打印字符串1 题目描述2 解题（Java）H2O 生成1 题目描述2 解题（Java）打印零与奇偶数1 题目描述2 解题（Java）交替打印FooBar1 题目描述2 解题（Java）按序打印1 题目描述2 解题（Java）2.1 解法1：共享变量2.2 解法2：信号量 哲学家进餐 1 题目描述 5 个沉默寡言的哲学家围坐在圆桌前，每人面前一盘意面。叉子放在哲学家之间的桌面上。（5 个哲学家，5 根叉子） 所有的哲学家都只会在思考和进餐两种行为间交替。哲学家
Leetcode——多线程编程——交替打印字符
spade_l的博客
04-09 116
编写一个可以从 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 FizzBuz
go语言打怪通关之 ⌈并发编程⌋
阿东的学习记录
04-21 460
文章目录定时器打点器工作池速率限制原子计数器 定时器 我们常常需要在后面一个时刻运行 Go 代码，或者在某段时间间隔内重复运行。Go 的内置 定时器 和 打点器 特性让这些很容易实现。 package main import "time" import "fmt" func main() { // 定时器表示在未来某一时刻的独立事件。你告诉定时器 // 需要等待的时间，然后它将提供一个用于通知的通道。 // 这里的定时器将等待 2 秒。 timer1 := time.N
用Go并发来解决leetcode的几道并发编程题
六六先森的博客
10-02 782
go语言实现leetcode并发题
【Go语言学习】——并发编程
Kaychenl的博客
06-10 432
并发编程
Go并发编程
qq_53267860的博客
03-08 661
目录并发编程并发介绍进程和线程并发和并行并发并行协程和线程goroutine 只是由官方实现的超级"线程池"。并发不是并行：Goroutine使用goroutine启动单个goroutine启动多个goroutine注意goroutine与线程可增长的栈goroutine调度GPM模型Goroutine调度器的GMP模型的设计思想GMP模型有关P和M的个数问题P和M何时会被创建runtime包runtime.Gosched()runtime.Goexit()runtime.GOMAXPROCSChannel
Go并发编程里的数据竞争以及解决之道
kevin_tech的博客，微信搜「网管叨bi叨」
05-27 855
Go语言以容易进行并发编程而闻名，但是如果稍不注意，并发程序可能导致的数据竞争问题（data race）就会经常出现在你编写的并发程序的待解决Bug列表中-- 如果你不幸在代码中遇到这种...
LeetCode-1195.交替打印字符串（多线程）
2.wa
02-06 791
LeetCode 题目描述 编写一个可以从 1 到 n 输出代表这个数字的字符串的程序，但是： 如果这个数字可以被 3 整除，输出 “fizz”。 如果这个数字可以被 5 整除，输出 “buzz”。 如果这个数字可以同时被 3 和 5 整除，输出 “fizzbuzz”。 例如，当 n = 15，输出： 1, 2, fizz, 4, buzz, fizz, 7, 8...
go语言并发快速排序
05-24
以下是使用 Go 语言实现的快速排序算法，并发地处理输入的数组。 ```go package main import ( "fmt" "math/rand" "sync" "time" ) func quickSort(arr []int, wg *sync.WaitGroup) { defer wg.Done() if ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值