python线程池超过最大数量_讨论一下Python线程池大小设置?

2017-02-03

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

疑问:对于n核和2n线程的处理器有什么需要注意的地方?

问题

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形)

2017-02-03

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

问题

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形)

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

问题

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形)

题外话

下面有些偏离了主题,主要想问上面的线程池大小设置问题。

concurrent.futures的文档中提到了它引入了异步的概念,但是我的一些实验结果并没有看出异步的效果,对于异步我的理解是支持多个网络IO并发同时进行,下面是实验结果,我将线程池的大小设置为5,在爬取的过程中,同一时刻最多只有5个网络IO并发进行,实在看不出异步的概念以及相比mutiprocessing.pool提供的ThreadPool的优势,各位网友是否能够解释一下?$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 0 0 192.168.0.103:58522 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 0 192.168.0.103:58518 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 808 192.168.0.103:57088 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 810 192.168.0.103:57092 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 806 192.168.0.103:57086 59.111.160.195:http ESTABLISHED 14427/python$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 5028 0 192.168.0.103:33012 59.111.160.195:http ESTABLISHED 14427/python

tcp 1 0 192.168.0.103:32998 59.111.160.195:http CLOSE_WAIT 14427/python

tcp 1 0 192.168.0.103:33006 59.111.160.195:http CLOSE_WAIT 14427/python

tcp 1 0 192.168.0.103:33004 59.111.160.195:http CLOSE_WAIT 14427/python

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

问题

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形)

题外话

下面有些偏离了主题,主要想问上面的线程池大小设置问题。

concurrent.futures的文档中提到了它引入了异步的概念,但是我的一些实验结果并没有看出异步的效果,对于异步我的理解是支持多个网络IO并发同时进行,下面是实验结果,我将线程池的大小设置为5,在爬取的过程中,同一时刻最多只有5个网络IO并发进行,实在看不出异步的概念以及相比mutiprocessing.pool提供的ThreadPool的优势,各位网友是否能够解释一下?$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 0 0 192.168.0.103:58522 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 0 192.168.0.103:58518 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 808 192.168.0.103:57088 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 810 192.168.0.103:57092 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 806 192.168.0.103:57086 59.111.160.195:http ESTABLISHED 14427/python$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 5028 0 192.168.0.103:33012 59.111.160.195:http ESTABLISHED 14427/python

tcp 1 0 192.168.0.103:32998 59.111.160.195:http CLOSE_WAIT 14427/python

tcp 1 0 192.168.0.103:33006 59.111.160.195:http CLOSE_WAIT 14427/python

tcp 1 0 192.168.0.103:33004 59.111.160.195:http CLOSE_WAIT 14427/python

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

问题

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形)

题外话

下面有些偏离了主题,主要想问线程池大小设置问题。

concurrent.futures的文档中提到了它引入了异步的概念,但是我的一些实验结果并没有看出异步的效果,对于异步我的理解是支持多个网络IO并发同时进行,下面是实验结果,我将线程池的大小设置为5,在爬取的过程中,同一时刻最多只有5个网络IO并发进行,实在看不出异步的概念以及相比mutiprocessing.pool提供的ThreadPool的优势,各位网友是否能够解释一下?$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 0 0 192.168.0.103:58522 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 0 192.168.0.103:58518 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 808 192.168.0.103:57088 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 810 192.168.0.103:57092 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 806 192.168.0.103:57086 59.111.160.195:http ESTABLISHED 14427/python$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 5028 0 192.168.0.103:33012 59.111.160.195:http ESTABLISHED 14427/python

tcp 1 0 192.168.0.103:32998 59.111.160.195:http CLOSE_WAIT 14427/python

tcp 1 0 192.168.0.103:33006 59.111.160.195:http CLOSE_WAIT 14427/python

tcp 1 0 192.168.0.103:33004 59.111.160.195:http CLOSE_WAIT 14427/python

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

问题

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形)

题外话

concurrent.futures的文档中提到了它引入了异步的概念,但是我的一些实验结果并没有看出异步的效果,对于异步我的理解是支持多个网络IO并发同时进行,下面是实验结果,我将线程池的大小设置为5,在爬取的过程中,同一时刻最多只有5个网络IO并发进行,实在看不出异步的概念以及相比mutiprocessing.pool提供的ThreadPool的优势,各位网友是否能够解释一下?(当然这有些偏离了主题,主要想问线程池大小设置问题)$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 0 0 192.168.0.103:58522 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 0 192.168.0.103:58518 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 808 192.168.0.103:57088 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 810 192.168.0.103:57092 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 806 192.168.0.103:57086 59.111.160.195:http ESTABLISHED 14427/python

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

问题

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形)

题外话

concurrent.futures的文档中提到了它引入了异步的概念,但是我的一些实验结果并没有看出异步的效果,对于异步我的理解是支持多个网络IO并发同时进行,下面是实验结果,我将线程池的大小设置为5,在爬取的过程中,同一时刻最多只有5个网络IO并发进行,实在看不出异步的概念以及相比mutiprocessing.pool提供的ThreadPool的优势,各位网友是否能够解释一下?(当然这有些偏离了主题,主要想问线程池大小设置问题)$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 0 0 192.168.0.103:58522 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 0 192.168.0.103:58518 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 808 192.168.0.103:57088 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 810 192.168.0.103:57092 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 806 192.168.0.103:57086 59.111.160.195:http ESTABLISHED 14427/python

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

问题

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形。)

题外话

concurrent.futures的文档中提到了它引入了异步的概念,但是我的一些实验结果并没有看出异步的效果,对于异步我的理解是支持多个网络IO并发同时进行,下面是实验结果,我将线程池的大小设置为5,在爬取的过程中,同一时刻最多只有5个网络IO并发进行,实在看不出异步的概念以及相比mutiprocessing.pool提供的ThreadPool的优势,各位网友是否能够解释一下?(当然这有些偏离了主题,主要想问线程池大小设置问题)$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 0 0 192.168.0.103:58522 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 0 192.168.0.103:58518 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 808 192.168.0.103:57088 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 810 192.168.0.103:57092 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 806 192.168.0.103:57086 59.111.160.195:http ESTABLISHED 14427/python

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

问题

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形。)

题外话

concurrent.futures的文档中提到了它引入了异步的概念,但是我的一些实验结果并没有看出异步的效果,对于异步我的理解是支持多个网络IO并发同时进行,下面是实验结果,我将线程池的大小设置为5,在爬取的过程中,同一时刻最多只有5个网络IO并发进行,实在看不出异步的概念以及相比mutiprocessing.pool提供的ThreadPool的优势,各位网友是否能够解释一下?$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 0 0 192.168.0.103:58522 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 0 192.168.0.103:58518 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 808 192.168.0.103:57088 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 810 192.168.0.103:57092 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 806 192.168.0.103:57086 59.111.160.195:http ESTABLISHED 14427/python

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

问题

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形。)

题外话

concurrent.futures的文档中提到了它引入了异步的概念,但是我的一些实验结果并没有看出异步的效果,对于异步我的理解是支持多个网络IO并发同时进行,下面是实验结果,我将线程池的大小设置为5,在爬取的过程中,同一时刻最多只有5个网络IO并发进行,实在看不出异步的概念以及相比mutiprocessing.pool提供的ThreadPool的优势,各位网友是否能够解释一下?$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 0 0 192.168.0.103:58522 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 0 192.168.0.103:58518 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 808 192.168.0.103:57088 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 810 192.168.0.103:57092 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 806 192.168.0.103:57086 59.111.160.195:http ESTABLISHED 14427/python

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形。)

题外话

concurrent.futures的文档中提到了它引入了异步的概念,但是我的一些实验结果并没有看出异步的效果,对于异步我的理解是支持多个网络IO并发同时进行,下面是实验结果,我将线程池的大小设置为5,在爬取的过程中,同一时刻最多只有5个网络IO并发进行,实在看不出异步的概念以及相比mutiprocessing.pool提供的ThreadPool的优势,各位网友是否能够解释一下?$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 0 0 192.168.0.103:58522 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 0 192.168.0.103:58518 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 808 192.168.0.103:57088 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 810 192.168.0.103:57092 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 806 192.168.0.103:57086 59.111.160.195:http ESTABLISHED 14427/python

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形。)

题外话

concurrent.futures的文档中提到了它引入了异步的概念,但是我的一些实验结果并没有看出异步的效果,我对于异步的理解是支持多个网络IO并发同时进行,下面是我的实验结果,我将线程池的大小设置为5,在爬取的过程中,同一时刻最多只有5个网络IO并发进行,实在看不出异步的概念以及相比mutiprocessing.pool提供的ThreadPool的优势,各位网友是否能够解释一下?$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 0 0 192.168.0.103:58522 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 0 192.168.0.103:58518 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 808 192.168.0.103:57088 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 810 192.168.0.103:57092 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 806 192.168.0.103:57086 59.111.160.195:http ESTABLISHED 14427/python

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形。)

题外话

concurrent.futures的文档中提到了它引入了异步的概念,但是我的一些实验结果并没有看出异步的效果,我对于异步的理解是支持多个网络IO并发都是进行,下面是我的一个实验结果,我将线程池的大小设置为5,在爬取的过程中,同一时刻最多只有5个网络IO并发进行,实在看不出异步的概念以及相比mutiprocessing.pool提供的ThreadPool的优势,各位网友是否能够解释一下?$ netstat -tup | grep 14427

(Not all processes could be identified, non-owned process info

will not be shown, you would have to be root to see it all.)

tcp 0 0 192.168.0.103:58522 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 0 192.168.0.103:58518 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 808 192.168.0.103:57088 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 810 192.168.0.103:57092 59.111.160.195:http ESTABLISHED 14427/python

tcp 0 806 192.168.0.103:57086 59.111.160.195:http ESTABLISHED 14427/python

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?(IO最好的办法是采用异步,主要想讨论下不支持异步的情形。)

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算型任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?

2017-02-02

更新问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算性任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?

2017-02-02

创建问题

讨论一下Python线程池大小设置?

在Java中,线程池大小通常被设置成CPU核心数+1,《Java Concurrency In Practise》8.2节中有这么一段话:对于计算密集型的任务,在拥有N个处理器的系统上,当线程池的大小为N+1时,通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时,这个额外的线程也能确保CPU的时钟周期不会被浪费。)

btw: 不太熟悉Java,网上引用,没经过实践。

并发编程网上也有一篇相关的文章,要点如下:如果是CPU密集型应用,则线程池大小设置为N+1

如果是IO密集型应用,则线程池大小设置为2N+1

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目

因为很显然,线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。

以上都是引用自Java,Python方面的资料相对较少,所以想讨论一下。

由于CPython中GIL存在,Python同一时刻只能运行一个线程,所以这里不讨论计算性任务,只看IO型任务,Python线程池大小应该怎么设置才算合理?

你可能感兴趣的:(python线程池超过最大数量)