Go 中的 channel 与 Java BlockingQueue 的本质区别
前言
最近在实现两个需求，因为二者之间并无依赖关系，因此想利用队列进行解耦；但在 Go 的标准库中并无现成可用而且并发安全的数据结构；但 Go 提供了一个更加优雅的解决方案，那就是 channel。java
channel 应用
Go 与 Java 的一个很大的区别就是并发模型不一样，Go 采用的是 CSP(Communicating sequential processes) 模型；用 Go 官方的说法：git
Do not communicate by sharing memory; instead, share memory by communicating.github
翻译过来就是：不用使用共享内存来通讯，而是用通讯来共享内存。编程
而这里所提到的通讯，在 Go 里就是指代的 channel。api
只讲概念并不能快速的理解与应用，因此接下来会结合几个实际案例更方便理解。安全
futrue task
Go 官方没有提供相似于 Java 的 FutureTask 支持：markdown
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(2);
Task task = new Task();
FutureTask<String> futureTask = new FutureTask<>(task);
executorService.submit(futureTask);
String s = futureTask.get();
System.out.println(s);
executorService.shutdown();
}
}
class Task implements Callable<String> {
@Override
public String call() throws Exception {
// 模拟http
System.out.println("http request");
Thread.sleep(1000);
return "request success";
}
}
复制代码
但咱们可使用 channel 配合 goroutine 实现相似的功能：数据结构
func main() {
ch := Request("https://github.com")
select {
case r := <-ch:
fmt.Println(r)
}
}
func Request(url string) <-chan string {
ch := make(chan string)
go func() {
// 模拟http请求
time.Sleep(time.Second)
ch <- fmt.Sprintf("url=%s, res=%s", url, "ok")
}()
return ch
}
复制代码
goroutine 发起请求后直接将这个 channel 返回，调用方会在请求响应以前一直阻塞，直到 goroutine 拿到了响应结果。并发
goroutine 互相通讯
/** * 偶数线程 */
public static class OuNum implements Runnable {
private TwoThreadWaitNotifySimple number;
public OuNum(TwoThreadWaitNotifySimple number) {
this.number = number;
}
@Override
public void run() {
for (int i = 0; i < 11; i++) {
synchronized (TwoThreadWaitNotifySimple.class) {
if (number.flag) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + "+-+偶数" + i);
number.flag = false;
TwoThreadWaitNotifySimple.class.notify();
}
} else {
try {
TwoThreadWaitNotifySimple.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
/** * 奇数线程 */
public static class JiNum implements Runnable {
private TwoThreadWaitNotifySimple number;
public JiNum(TwoThreadWaitNotifySimple number) {
this.number = number;
}
@Override
public void run() {
for (int i = 0; i < 11; i++) {
synchronized (TwoThreadWaitNotifySimple.class) {
if (!number.flag) {
if (i % 2 == 1) {
System.out.println(Thread.currentThread().getName() + "+-+奇数" + i);
number.flag = true;
TwoThreadWaitNotifySimple.class.notify();
}
} else {
try {
TwoThreadWaitNotifySimple.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
复制代码
这里截取了”两个线程交替打印奇偶数“的部分代码。编程语言
Java 提供了 object.wait()/object.notify() 这样的等待通知机制，能够实现两个线程间通讯。
go 经过 channel 也能实现相同效果：
func main() {
ch := make(chan struct{})
go func() {
for i := 1; i < 11; i++ {
ch <- struct{}{}
//奇数
if i%2 == 1 {
fmt.Println("奇数:", i)
}
}
}()
go func() {
for i := 1; i < 11; i++ {
<-ch
if i%2 == 0 {
fmt.Println("偶数:", i)
}
}
}()
time.Sleep(10 * time.Second)
}
复制代码
本质上他们都是利用了线程(goroutine)阻塞而后唤醒的特性，只是 Java 是经过 wait/notify 机制；
而 go 提供的 channel 也有相似的特性：
- 向
channel发送数据时(ch<-struct{}{})会被阻塞，直到 channel 被消费(<-ch)。
以上针对于
无缓冲 channel。
channel 自己是由 go 原生保证并发安全的，不用额外的同步措施，能够放心使用。
广播通知
不只是两个 goroutine 之间通讯，一样也能广播通知，相似于以下 Java 代码：
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
synchronized (NotifyAll.class){
NotifyAll.class.wait();
}
System.out.println(Thread.currentThread().getName() + "done....");
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
Thread.sleep(3000);
synchronized (NotifyAll.class){
NotifyAll.class.notifyAll();
}
}
复制代码
主线程将全部等待的子线程所有唤醒，这个本质上也是经过 wait/notify 机制实现的，区别只是通知了全部等待的线程。
换作是 go 的实现：
func main() {
notify := make(chan struct{})
for i := 0; i < 10; i++ {
go func(i int) {
for {
select {
case <-notify:
fmt.Println("done.......",i)
return
case <-time.After(1 * time.Second):
fmt.Println("wait notify",i)
}
}
}(i)
}
time.Sleep(1 * time.Second)
close(notify)
time.Sleep(3 * time.Second)
}
复制代码
当关闭一个 channel 后，会使得全部获取 channel 的 goroutine 直接返回，不会阻塞，正是利用这一特性实现了广播通知全部 goroutine 的目的。
注意，同一个 channel 不能反复关闭，否则会出现panic。
channel 解耦
以上例子都是基于无缓冲的 channel，一般用于 goroutine 之间的同步；同时 channel 也具有缓冲的特性：
ch :=make(chan T, 100)
复制代码
能够直接将其理解为队列，正是由于具备缓冲能力，因此咱们能够将业务之间进行解耦，生产方只管往 channel 中丢数据，消费者只管将数据取出后作本身的业务。
同时也具备阻塞队列的特性：
- 当
channel写满时生产者将会被阻塞。 - 当
channel为空时消费者也会阻塞。
从上文的例子中能够看出，实现相同的功能 go 的写法会更加简单直接，相对的 Java 就会复杂许多（固然这也和这里使用的偏底层 api 有关）。
Java 中的 BlockingQueue
这些特性都与 Java 中的 BlockingQueue 很是相似，他们具备如下的相同点：
- 能够经过二者来进行
goroutine/thread通讯。 - 具有队列的特征，能够解耦业务。
- 支持并发安全。
一样的他们又有很大的区别，从表现上看：
channel支持select语法，对channel的管理更加简洁直观。channel支持关闭，不能向已关闭的channel发送消息。channel支持定义方向，在编译器的帮助下能够在语义上对行为的描述更加准确。
固然还有本质上的区别就是 channel 是 go 推荐的 CSP 模型的核心，具备编译器的支持，能够有很轻量的成本实现并发通讯。
而 BlockingQueue 对于 Java 来讲只是一个实现了并发安全的数据结构，即使不使用它也有其余的通讯方式；只是他们都具备阻塞队列的特征，全部在初步接触 channel 时容易产生混淆。
| 相同点 | channel 特有 |
|---|---|
| 阻塞策略 | 支持select |
| 设置大小 | 支持关闭 |
| 并发安全 | 自定义方向 |
| 普通数据结构 | 编译器支持 |
总结
有过一门编程语言的使用经历在学习其余语言是确实是要方便许多，好比以前写过 Java 再看 Go 时就会发现许多相似之处，只是实现不一样。
拿这里的并发通讯来讲，本质上是由于并发模型上的不一样；
Go 更推荐使用通讯来共享内存，而 Java 大部分场景都是使用共享内存来通讯（这样就得加锁来同步）。
带着疑问来学习确实会事半功倍。
最近和网友讨论后再补充一下，其实 Go channel 的底层实现也是经过对共享内存的加锁来实现的，这点任何语言都不可避免。
既然都是共享内存那和咱们本身使用共享内存有什么区别呢？主要仍是 channel 的抽象层级更高，咱们使用这类高抽象层级的方式编写代码会更易理解和维护。
但在一些特殊场景，须要追求极致的性能，下降加锁颗粒度时用共享内存会更加合适，因此 Go 官方也提供有 sync.Map/Mutex 这样的库；只是在并发场景下更推荐使用 channel 来解决问题。
- 1. Java中的BlockingQueue
- 2. Go 缓冲 channel 和 非缓冲 channel 的区别
- 3. CommonJS与ES6 Module的本质区别
- 4. CreateThread与_beginthreadex本质区别
- 5. char 与 unsigned char的本质区别
- 6. require与import的本质区别
- 7. 库与框架的本质区别
- 8. Java中，&&与&，||与|的区别
- 9. java中 &&与& ||与| 的区别
- 10. Java中，&&与&；||与|的区别
- 更多相关文章...
- • Redis在Java Web中的应用 - Redis教程
- • Java 中操作 R - R 语言教程
- • Docker容器实战(八) - 漫谈 Kubernetes 的本质
- • C# 中 foreach 遍历的用法
-
每一个你不满意的现在，都有一个你没有努力的曾经。