golang是第一个大规模multi-core, N：M thread model Language# Programming - 葵花宝典
D*e
1 楼
丝瓜络要多老的丝瓜才有？现在有些皮变黄了，可以摘下来再放老吗？等着翻地种别的
。
。
c*v
2 楼
wdong 2015年说过这个关键的地方。
这几年下来，基本情况没update。
(1)
Golang 可以自动调度N任务在M kernel线程across P multi-cores。
这个不管做得好坏。难度是非常大的。
linux是1:1.
(2) Rust : https://doc.rust-lang.org/1.24.1/book/second-edition/ch16-01-
threads.html
The green threading M:N model requires a larger language runtime to manage
threads. As such, the Rust standard library only provides an implementation
of 1:1 threading.
(3)
2012 Golang scheduler design spec
https://docs.google.com/document/d/1TTj4T2JO42uD5ID9e89oa0sLKhJYD0Y_
kqxDv3I3XMw/edit
这几年下来，基本情况没update。
(1)
Golang 可以自动调度N任务在M kernel线程across P multi-cores。
这个不管做得好坏。难度是非常大的。
linux是1:1.
(2) Rust : https://doc.rust-lang.org/1.24.1/book/second-edition/ch16-01-
threads.html
The green threading M:N model requires a larger language runtime to manage
threads. As such, the Rust standard library only provides an implementation
of 1:1 threading.
(3)
2012 Golang scheduler design spec
https://docs.google.com/document/d/1TTj4T2JO42uD5ID9e89oa0sLKhJYD0Y_
kqxDv3I3XMw/edit
L*A
3 楼
什么是丝瓜络？
s*i
4 楼
请教，这个特性是语言层面的还是底层实现的问题？其他语言有没有可能逐渐也实现这
个呢？
个呢？
D*e
5 楼
就是老丝瓜的瓤，洗碗用
【在 L****A 的大作中提到】
: 什么是丝瓜络？
【在 L****A 的大作中提到】
: 什么是丝瓜络？
c*v
6 楼
理论上我觉得这应该是OS干的事。实现这个很难。
不管是谁.
一来spec难写。不知道该满足哪一类需求。
第二，就算spec写了。不管啥资源，task assignment时不时的就会冒出来NP hard啊。
那么只能用一些简单但是强壮的基本方法。写好以后，再回过头改问题的定义，甚至要
求程序员follow 所谓的goog practice。
From effective java:
The best way to write a robust, responsive, portable program is to ensure
that the average number of runnable threads is not significantly greater
than the number of processors. This leaves the thread scheduler with little
choice: it simply runs the runnable threads till they’re no longer runnable.
这个对scheduler的不信任不能说完全不合理。
【在 s*i 的大作中提到】
: 请教，这个特性是语言层面的还是底层实现的问题？其他语言有没有可能逐渐也实现这
: 个呢？
不管是谁.
一来spec难写。不知道该满足哪一类需求。
第二，就算spec写了。不管啥资源，task assignment时不时的就会冒出来NP hard啊。
那么只能用一些简单但是强壮的基本方法。写好以后，再回过头改问题的定义，甚至要
求程序员follow 所谓的goog practice。
From effective java:
The best way to write a robust, responsive, portable program is to ensure
that the average number of runnable threads is not significantly greater
than the number of processors. This leaves the thread scheduler with little
choice: it simply runs the runnable threads till they’re no longer runnable.
这个对scheduler的不信任不能说完全不合理。
【在 s*i 的大作中提到】
: 请教，这个特性是语言层面的还是底层实现的问题？其他语言有没有可能逐渐也实现这
: 个呢？
m*6
7 楼
我们那里叫丝瓜经。
你等着翻地种其他菜的话，不值得等丝瓜络的。
1刀多的洗碗刷可以用N年了，
丝瓜络用不了多久就玩菜了，纯粹怀旧用用，不能当回事儿。
你等着翻地种其他菜的话，不值得等丝瓜络的。
1刀多的洗碗刷可以用N年了，
丝瓜络用不了多久就玩菜了，纯粹怀旧用用，不能当回事儿。
h*i
8 楼
No.
Every languages worth mentioning today have these.
implementation
【在 c*******v 的大作中提到】
: wdong 2015年说过这个关键的地方。
: 这几年下来，基本情况没update。
: (1)
: Golang 可以自动调度N任务在M kernel线程across P multi-cores。
: 这个不管做得好坏。难度是非常大的。
: linux是1:1.
: (2) Rust : https://doc.rust-lang.org/1.24.1/book/second-edition/ch16-01-
: threads.html
: The green threading M:N model requires a larger language runtime to manage
: threads. As such, the Rust standard library only provides an implementation
Every languages worth mentioning today have these.
implementation
【在 c*******v 的大作中提到】
: wdong 2015年说过这个关键的地方。
: 这几年下来，基本情况没update。
: (1)
: Golang 可以自动调度N任务在M kernel线程across P multi-cores。
: 这个不管做得好坏。难度是非常大的。
: linux是1:1.
: (2) Rust : https://doc.rust-lang.org/1.24.1/book/second-edition/ch16-01-
: threads.html
: The green threading M:N model requires a larger language runtime to manage
: threads. As such, the Rust standard library only provides an implementation
y*8
9 楼
皮要变黄变脆才行的，觉得可以摘下来放老的，放太阳下多晒晒应该能管用。
【在 D***e 的大作中提到】
: 丝瓜络要多老的丝瓜才有？现在有些皮变黄了，可以摘下来再放老吗？等着翻地种别的
: 。
【在 D***e 的大作中提到】
: 丝瓜络要多老的丝瓜才有？现在有些皮变黄了，可以摘下来再放老吗？等着翻地种别的
: 。
g*t
10 楼
(1)
Java by default自带是1：1的(自己写的不算。)。这源自于当初Solaris，linux没搞
定。
java跟着OS走。我查了一下，多年前这方面的论文还颇有一些。
以前java社区应该是有过1：N的。我记不确切了。
但是三层调度，java社区也好，别的社区也好，都是我没有见过的。
another example我贴过了。rust文档如下：
The green threading M:N model requires a larger language runtime to manage
threads. As such, the Rust standard library only provides an implementation
of 1:1 threading.
(2)
Golang这个三层调度应用效果如何先不讲。
实事求是的讲，没有失败还是很厉害的。这条路可以说已经开出来了。
再过5年，精通golang性能调优的专家就会流行的。
就跟今日懂jvm的人类似。
【在 h*i 的大作中提到】
: No.
: Every languages worth mentioning today have these.
:
: implementation
Java by default自带是1：1的(自己写的不算。)。这源自于当初Solaris，linux没搞
定。
java跟着OS走。我查了一下，多年前这方面的论文还颇有一些。
以前java社区应该是有过1：N的。我记不确切了。
但是三层调度，java社区也好，别的社区也好，都是我没有见过的。
another example我贴过了。rust文档如下：
The green threading M:N model requires a larger language runtime to manage
threads. As such, the Rust standard library only provides an implementation
of 1:1 threading.
(2)
Golang这个三层调度应用效果如何先不讲。
实事求是的讲，没有失败还是很厉害的。这条路可以说已经开出来了。
再过5年，精通golang性能调优的专家就会流行的。
就跟今日懂jvm的人类似。
【在 h*i 的大作中提到】
: No.
: Every languages worth mentioning today have these.
:
: implementation
y*8
11 楼
我们也叫丝瓜巾！
【在 m**6 的大作中提到】
: 我们那里叫丝瓜经。
: 你等着翻地种其他菜的话，不值得等丝瓜络的。
: 1刀多的洗碗刷可以用N年了，
: 丝瓜络用不了多久就玩菜了，纯粹怀旧用用，不能当回事儿。
【在 m**6 的大作中提到】
: 我们那里叫丝瓜经。
: 你等着翻地种其他菜的话，不值得等丝瓜络的。
: 1刀多的洗碗刷可以用N年了，
: 丝瓜络用不了多久就玩菜了，纯粹怀旧用用，不能当回事儿。
g*t
12 楼
Java is 1:1, from reedit by a Phd in concurrency:
"
A thread pool does not let me have M stacks at a time. It only lets me have
N - the same number of OS threads. You cannot take a task running on a
threadpool thread and suspend it, can you? You can a goroutine or Erlang
process.
That's why it's thread pools aren't M:N - they only have N stacks. They're N
:N (so 1:1), with an extra queue of M jobs, but they aren't running until
there's space in the N OS threads.
Goroutines do not have the same problem as I've described, because they can
run M stacks at a time - M jobs can make progress towards meeting at the
barrier, and then cooperatively (so we don't need preemption here - they're
doing it cooperatively so not being preemptible isn't relevant here)
deschedule themselves while waiting at the barrier, allowing another of the
goroutines to be scheduled and to make progress.
Source: I wrote a PhD on concurrency and parallelism models and programming
language implementation, and I work at Oracle on Java virtual machines.
"
【在 h*i 的大作中提到】
: No.
: Every languages worth mentioning today have these.
:
: implementation
"
A thread pool does not let me have M stacks at a time. It only lets me have
N - the same number of OS threads. You cannot take a task running on a
threadpool thread and suspend it, can you? You can a goroutine or Erlang
process.
That's why it's thread pools aren't M:N - they only have N stacks. They're N
:N (so 1:1), with an extra queue of M jobs, but they aren't running until
there's space in the N OS threads.
Goroutines do not have the same problem as I've described, because they can
run M stacks at a time - M jobs can make progress towards meeting at the
barrier, and then cooperatively (so we don't need preemption here - they're
doing it cooperatively so not being preemptible isn't relevant here)
deschedule themselves while waiting at the barrier, allowing another of the
goroutines to be scheduled and to make progress.
Source: I wrote a PhD on concurrency and parallelism models and programming
language implementation, and I work at Oracle on Java virtual machines.
"
【在 h*i 的大作中提到】
: No.
: Every languages worth mentioning today have these.
:
: implementation
B*a
13 楼
有一次在老墨店看到有卖丝瓜瓤子的，洗澡用
【在 D***e 的大作中提到】
: 就是老丝瓜的瓤，洗碗用
【在 D***e 的大作中提到】
: 就是老丝瓜的瓤，洗碗用
a*e
14 楼
Haskell GHC 从 04 年就支持 N:M 调度了。
Go 这些年没啥好吹的才来吹 green thread / co-routine，因为之前它的 GC 太烂了。
implementation
【在 c*******v 的大作中提到】
: wdong 2015年说过这个关键的地方。
: 这几年下来，基本情况没update。
: (1)
: Golang 可以自动调度N任务在M kernel线程across P multi-cores。
: 这个不管做得好坏。难度是非常大的。
: linux是1:1.
: (2) Rust : https://doc.rust-lang.org/1.24.1/book/second-edition/ch16-01-
: threads.html
: The green threading M:N model requires a larger language runtime to manage
: threads. As such, the Rust standard library only provides an implementation
Go 这些年没啥好吹的才来吹 green thread / co-routine，因为之前它的 GC 太烂了。
implementation
【在 c*******v 的大作中提到】
: wdong 2015年说过这个关键的地方。
: 这几年下来，基本情况没update。
: (1)
: Golang 可以自动调度N任务在M kernel线程across P multi-cores。
: 这个不管做得好坏。难度是非常大的。
: linux是1:1.
: (2) Rust : https://doc.rust-lang.org/1.24.1/book/second-edition/ch16-01-
: threads.html
: The green threading M:N model requires a larger language runtime to manage
: threads. As such, the Rust standard library only provides an implementation
y*8
15 楼
老美店也有。做成手套的形状，很漂亮的，就是价格不菲了。
【在 B*******a 的大作中提到】
: 有一次在老墨店看到有卖丝瓜瓤子的，洗澡用
【在 B*******a 的大作中提到】
: 有一次在老墨店看到有卖丝瓜瓤子的，洗澡用
h*i
16 楼
No.
Why do you quote a stupid person who has not worked in any real application?
I said in this board a few weeks ago, "Don't listen to these stupid
recommendation about how many threads should be in your thread pool."
Listen to me: use thousands of threads in your pool.
The reason is simple, most modern programming is doing IO, so you block on
IO everywhere: network requests, database request, file system, EVERYWHERE.
You need those threads in your async thread pool, otherwise, you will
quickly run out of threads because all of them are waiting on something.
I know, you are not "supposed" to block in the "async" code, but NO, you
WILL be blocking in your async code, because all the low level stuff are
blocking.
Don't read stupid comments on the Internet, instead, build things and try
things yourself.
have
N
can
【在 g****t 的大作中提到】
: Java is 1:1, from reedit by a Phd in concurrency:
: "
: A thread pool does not let me have M stacks at a time. It only lets me have
: N - the same number of OS threads. You cannot take a task running on a
: threadpool thread and suspend it, can you? You can a goroutine or Erlang
: process.
: That's why it's thread pools aren't M:N - they only have N stacks. They're N
: :N (so 1:1), with an extra queue of M jobs, but they aren't running until
: there's space in the N OS threads.
: Goroutines do not have the same problem as I've described, because they can
Why do you quote a stupid person who has not worked in any real application?
I said in this board a few weeks ago, "Don't listen to these stupid
recommendation about how many threads should be in your thread pool."
Listen to me: use thousands of threads in your pool.
The reason is simple, most modern programming is doing IO, so you block on
IO everywhere: network requests, database request, file system, EVERYWHERE.
You need those threads in your async thread pool, otherwise, you will
quickly run out of threads because all of them are waiting on something.
I know, you are not "supposed" to block in the "async" code, but NO, you
WILL be blocking in your async code, because all the low level stuff are
blocking.
Don't read stupid comments on the Internet, instead, build things and try
things yourself.
have
N
can
【在 g****t 的大作中提到】
: Java is 1:1, from reedit by a Phd in concurrency:
: "
: A thread pool does not let me have M stacks at a time. It only lets me have
: N - the same number of OS threads. You cannot take a task running on a
: threadpool thread and suspend it, can you? You can a goroutine or Erlang
: process.
: That's why it's thread pools aren't M:N - they only have N stacks. They're N
: :N (so 1:1), with an extra queue of M jobs, but they aren't running until
: there's space in the N OS threads.
: Goroutines do not have the same problem as I've described, because they can
相关阅读
Java8的FP真的真的很难用Java EE 问题美国的程序员群体中，滥竽充数的比例有多少？继续纠结spark架网站的码工，是新时代的打字员，都是机械工作 (转载)求教怎么建一个AWS的real time scoring engine？现在Go有没有restful framework胜出呢？狂笑——习特勒得知 AlphaGo战胜李世石（视频）推荐个免费的人工智能软件 Pachi本地搜索local service 原理搞开发太无聊了，整天就是被迫跟进各种新的轮子framework搜索系统设计深度学习真正有实用价值的应用Many-to-Many 关系数据存储7，8年没用linux，猛然发现linux比windows还kidunordered_map<int, xxx>到底有多快新华社通稿：围棋将迎来美丽的新世界kaggle上那批人太逆天了问一个多线程的问题linux 能查到 deleted file list 吗