评论

收藏

Go 中的 channel 与 Java BlockingQueue 的本质区别

服务系统 服务系统 发布于:2021-07-06 09:04 | 阅读数:460 | 评论:0

DSC0000.jpg

前言
  最近在实现两个需求,由于两者之间并没有依赖关系,所以想利用队列进行解耦;但在 Go 的标准库中并没有现成可用并且并发安全的数据结构;但 Go 提供了一个更加优雅的解决方案,那就是 channel。
channel 应用
  Go 与 Java 的一个很大的区别就是并发模型不同,Go 采用的是 CSP(Communicating sequential processes) 模型;用 Go 官方的说法:
  Do not communicate by sharing memory; instead, share memory by communicating.
  翻译过来就是:不用使用共享内存来通信,而是用通信来共享内存。
  而这里所提到的通信,在 Go 里就是指代的 channel。
  只讲概念并不能快速的理解与应用,所以接下来会结合几个实际案例更方便理解。
futrue task
  Go 官方没有提供类似于 Java 的 FutureTask 支持:
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 来解决问题。

关注下面的标签,发现更多相似文章