js-csp 能够最先尝试了

2024年4月4日 150次阅读 来源: 题恭弘=叶 恭弘

CSP 的用例

CSP 的用法最早是 Go 言语传开来的, 看一下我从网上扒的代码:

package main

import "fmt"

func ping(pings chan<- string, msg string) {
    pings <- msg
}

func pong(pings <-chan string, pongs chan<- string) {
    msg := <-pings
    pongs <- msg
}

func main() {
    pings := make(chan string, 1)
    pongs := make(chan string, 1)
    ping(pings, "passed message")
    pong(pings, pongs)
    fmt.Println(<-pongs)
}

个中 <- 标记是往 channel 当中写入数据的操纵.
同时注重平常 <- 的位置关于 goroutine 来讲是壅塞的,
因为 channel 能够处置惩罚异步操纵, 也就是说能做到异步代码用同步写法.
更多的细节搜刮 “go channel” 应当就能够找到.

除了 Go, Clojure 也完成了关于 CSP 的支撑, 也就是 core.async 这个库,
在 Clojure 当中语法做了调解, 成了 >! <! 如许的写法, 有点怪,
然则基本功用差不多, >! 和 <! 都是模仿的壅塞, channel 观点也一样:

(let [c1 (chan)
      c2 (chan)]
  (go (while true
        (let [[v ch] (alts! [c1 c2])]
          (println "Read" v "from" ch))))
  (go (>! c1 "hi"))
  (go (>! c2 "there")))

这个例子当中 (chan) 天生 channel, 然后用 go 天生 3 个线索…
虽然用了 while true, 然则经由过程 alts! 也构成了壅塞.
更新细节搜刮 “core.async” 能够找到.

为什么用 CSP

看 Wiki https://en.wikipedia.org/wiki…

In computer science, communicating sequential processes (CSP) is a formal language for describing patterns of interaction in concurrent systems.[1] It is a member of the family of mathematical theories of concurrency known as process algebras, or process calculi, based on message passing via channels. CSP was highly influential in the design of the occam programming language,1 and also influenced the design of programming languages such as Limbo[3] and Go.[4]

CSP 本来是用于形貌并发的体系之间怎样交互的, 也就是在 Go 当中的用法.
因为并发的操纵一般都是异步的, 所以 CSP 也能合适异步的行动.
最主要的观点就是 Channel, 也叫做”管道”, Channel 能够用于传输数据,
因此就有关于管道读和写的操纵, 分别是 take! 和 put!, Clojure 里的叫法.
前面说了, 管道看上去是壅塞代码执行的, 也就是说读和写能够举行守候.
如许就能够模仿一些场景, 比方抓取收集数据再打印, 就很轻易写出来了.

罕见功用另有 alts!, 对应 Go 的 select, 就是多个 Channel 取起首返回的数据,
另有 merge 记不大清, 好像是汇总多个 Channel 返回的数据, 变成一个?
其他的 filter, map 等等序列的操纵, 在 Channel 上也有相似执行,
另一方面 CSP 在有用当中应当是举行了扩大, 现实功用不止这些.
比方说增加了 (timeout 1000) 如许的 Channel 守候一秒返回数据,
另有对 Channel 举行 Buffer 的功用, 以及异步的推数据等等.

听起来很花梢, 然则假如有动画能够展现一下就很清晰了, 我还没找到…
从团体的思绪上说, 这是关于异步事宜的一种笼统, 能够用来完成许多营业.
想一想方法再诠释细节吧, 我这里先引见 JavaScript 这边的状况…

js-csp 的近况

因为 Node 6 最先有 yield, 用同步代码写异步成为了能够,
因而有就有了 js-csp 这个模块, 经由过程 yield 完成了 CSP 的功用,
我还看到一个用了 async 的, 预计不能用, 然则供参考:

https://github.com/ubolonton/…
https://github.com/dvlsg/asyn…

我直接贴一遍 README 当中的例子, 本身看看能不能看懂:

function* player(name, table) {
  while (true) {
    var ball = yield csp.take(table); // 守候获得数据
    if (ball === csp.CLOSED) { // 封闭状况特别处置惩罚
      console.log(name + ": table's gone");
      return;
    }
    ball.hits += 1;
    console.log(name + " " + ball.hits);
    yield csp.timeout(100); // 守候延时完毕
    yield csp.put(table, ball); // 推数据并守候对方取
  }
}

csp.go(function* () {
  var table = csp.chan(); // 建立 Channel

  csp.go(player, ["ping", table]); // 相当于启动 goroutine
  csp.go(player, ["pong", table]); // 相当于启动 goroutine

  yield csp.put(table, {hits: 0}); // 推数据守候对方取
  yield csp.timeout(1000); // 守候延时完毕
  table.close();
});

运转的结果是:

=>> node go.js
ping 1
pong 2
ping 3
pong 4
ping 5
pong 6
ping 7
pong 8
ping 9
pong 10
ping: table's gone
pong: table's gone

如许模仿的就是两个历程之间互相发送数据的场景.

但现实上 CSP 能够对事宜流举行笼统, 也就能够做出更壮大的功用.
这就是在我之前引荐的这篇文章上的做的引见, 点进去看吧:
http://jlongster.com/Taming-t…

跟着浏览器和 Node 对 yield 支撑的完美, 运用 js-csp 已能够做到.
考虑到计划的天真性, 我以为值得往深了去挖一挖.

和 Rx 的对照

事宜流的另一套著名的计划就是 Rx, 有 js 版本的 Rxjs.
也许来讲, Rx 是用 OOP 语法封装的 FP 作风的相应式编程计划, 操纵繁多,
而 CSP 经由过程管道供应的是一些天真但过于基本的原语,
看社区的议论, 其实有很大的堆叠的部份, 只管细节还很难说…
我搜集了一些文章:

https://medium.com/@puppybits…

另有 GitHub 上的一些议论:

https://github.com/ubolonton/…
https://github.com/cyclejs/cy…

别的另有或人用 Rx 写法模仿 CSP 计划的博客:

http://swannodette.github.io/…
http://swannodette.github.io/…
http://potetm.github.io/2014/…
http://potetm.github.io/2014/…

小结

说起来我还没怎样消化这东西.. 然则假如看过文章里的 Demo, 你肯定印象深入,
流是数据和时候绑定在一起构成的产品, 一般的编程手段很难处置惩罚,
然则 CSP 的观点让处置惩罚 Channel 中通报的数据成为了而比较天真的事变.
参考外洋社区的批评, 这是具有相当大代价的一块学问, 所以在延续跟进.

    原文作者：题恭弘=叶 恭弘
    原文地址: https://segmentfault.com/a/1190000006865102
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞