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

最新推荐文章于 2023-08-15 23:53:56 发布
最新推荐文章于 2023-08-15 23:53:56 发布
阅读量1.2k 收藏
点赞数
文章标签： 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线程池大小应该怎么设置才算合理？

weixin_39730587
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python自定义线程池控制线程数量的示例
09-19
今天小编就为大家分享一篇python自定义线程池控制线程数量的示例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
python threading库设置最大线程
NLOS的博客
03-17 1470
这里使用with semaphore语句，确保在代码块内的操作完成后，信号量会被正确释放。这样，其他等待的线程就能获取到信号量并开始执行。在使用python的threading库时，希望如何设置最大线程数N_max。
Not all processes could be identified, non-owned process info will not be show解决办法
进阶的蜗牛
08-16 3万+
Not all processes could be identified, non-owned process info will not be show解决办法 背景 今天在调试脚本的时候，打印出的日志中出现了 “Not all processes could be identified, non-owned process info will not be shown, you would...
python限制最大线程数（不一样的方法）
qq_24082937的博客
12-09 7552
实际工作中会遇到有成千上万个任务想使用多线程来完成，而计算机无法同时处理这么多线程，通常来说会因为内存消耗完而无法创建新的线程。 在诸多大佬的博客中找到如下解决方案： import threading import time sem=threading.Semaphore(4) #限制线程的最大数量为4个 def gothread(): with sem: #锁定线程的最大数量 for i in range(100000): print(threading.current_t
linux netsat -tnlp - 看不见
编程之美
05-10 2141
场景：因为使用了netstat -p参数。权限问题，zabbix_agentd是zabbix用户启动的，默认不能执行netstat -p等命令，导致从服务器取到的自动发现脚本为空(Not all processes could be identified, non-owned process info will not be shown, you would have to be root to ...
python中怎么确定线程池配置的最大线程数_害 其实银行就是一个Java线程池
weixin_28432777的博客
01-21 1393
银行就是一个线程池银行实际上就是一个Java线程池。一次周末去银行办业务，人多排号，排的久了突然发现银行实际上和Java的线程池如此类似，可以说一模一样。于是我就展开了联想。银行是个线程池周末，银行七个窗口只来了两个值班的员工，那么这两个员工我们就叫做核心员工数那天由于不知道什么原因，来银行办业务的人特别多，两个员工很快就忙不过来了，那么新来的人怎么办呢？只能排个号在休息区的椅子上坐着等，这一排椅...
浅谈python 线程池threadpool之实现
09-21
主要介绍了浅谈python 线程池threadpool之实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
python线程池threadpool实现篇
09-20
主要为大家详细介绍了python线程池threadpool的实现，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
实例代码讲解Python 线程池
09-16
主要介绍了Python 线程池的相关资料，帮助大家更好的理解和学习python，感兴趣的朋友可以了解下
Python线程池模块ThreadPoolExecutor用法分析
09-19
主要介绍了Python线程池模块ThreadPoolExecutor用法,结合实例形式分析了Python线程池模块ThreadPoolExecutor的导入与基本使用方法,需要的朋友可以参考下
python线程池超过最大数量_python多线程：控制线程数量
weixin_39743414的博客
11-28 460
#-*- coding:utf-8 -*-importrequestsfrom requests.exceptions importRequestExceptionimportos, timeimportrefrom lxml importetreeimportthreadinglock=threading.Lock()defget_html(url):"""定义一个方法，用于获取一个url页面的...
Not all processes could be identified, non-owned process info will not be show解决办法
灵感点滴的分享
06-15 4904
Not all processes could be identified, non-owned process info will not be show解决办法 背景 今天在调试脚本的时候，打印出的日志中出现了 “Not all processes could be identified, non-owned process info will not be shown, you would have to be root to see it all.” 错误 原因 经过排查后发现脚本中有运行 nets
03-多线程【100个Python知识点】
子午的博客
09-17 304
在开发中，有时会遇到一些比较耗时的操作，如文件批量下载，批量处理等情况，这时我们为了实现更快的相应，可以使用多线程实现异步任务。也可以通过多线程充分的利用CPU的资源，加快处理速度。
Python多线程与线程池（python线程池ThreadPoolExecutor）concurrent.futures高级别异步执行封装
最新发布
Dontla的博客
08-15 7075
线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
python线程数量与线程池
二狗的博客
01-13 481
从回答者的观点来看，不要揣测线程的最大承受数量，可以切实去尝试，去触碰它的上界。也就是通过试验，找到运行最快，又不出任何问题的那个数量，即使这个数量非常大，也不用无畏地担心。首先声明，1个线程分5个的想法是不行的，因为每个线程运行时间带有随机性，如果任务平均分配，则很可能出现一个线程还在苦苦工作，而另一个线程已经完成，却无法帮助前一个线程分担的情况，这无疑会降低运行效率。不过如果我们指定线程池的线程数（其实就是同时可开启的最大线程数量，超过则等待），指定为10以上，效率提升可以和循环情况相同。
【python学习】最优雅的创建多线程+线程池+同步锁+限制最大并发数（使用类创建）
AA8j的博客
03-19 294
代码 import threading import time sem = threading.Semaphore(3) # 限制线程的最大数量为3个 class GoThread(threading.Thread): def __init__(self, num): super().__init__() self.num = num def run(self): # 总共要数多少个数 for i in range(s
Not all processes could be identified, non-owned process info will not be shown, you would have to ...
weixin_30275415的博客
11-16 1525
分析：还是权限问题，所以给他加上权限就可以了！！ 解决：chmod +s /bin/netstat 转载于:https://www.cnblogs.com/yeyu1314/p/9970593.html
zabbix技术遇到的问题7--Not all processes could be identified, non-owned process info will not be shown...
weixin_44736359的博客
07-09 662
遇到的问题 [root@m01 ~]# zabbix_get -s 10.0.0.61 -k mysql.discovery (Not all processes could be identified, non-owned process info will not be shown, you would have to be root to see it all.) {"data":[]} 原因： zabbix用户不能使用netstat的-p参数 解决方法： 给netstat命令添加s权限 [roo
端口访问被拒绝的解决方案
热门推荐
空白_回忆的博客
04-26 4万+
端口访问被拒绝的解决方案 问题描述： 比如在本机telent到192.168.8.170 主机的9000 端口，被拒绝。 [zhu@hadoop log]$ telnet 192.168.8.170 9000 Trying 192.168.8.170... telnet: connect to address 192.168.8.170: Connection refused 原因：原因有两...
python线程池回调函数_第11天续，Python并发编程之线程池/进程池
05-31
好的，关于线程池回调函数，可以在提交任务时指定回调函数，当任务完成时，线程池会自动调用回调函数，以通知任务已经完成。 在Python中，可以使用concurrent.futures模块中的ThreadPoolExecutor来创建线程池，通过submit()方法向线程池提交任务，可以指定回调函数。下面是示例代码： ```python import concurrent.futures def callback_func(future): # 回调函数 print("Task done.") def worker_func(num): # 模拟一个耗时的任务 return num * num if __name__ == '__main__': # 创建线程池 with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor: # 提交任务 future = executor.submit(worker_func, 5) # 指定回调函数 future.add_done_callback(callback_func) ``` 这个例子中，我们创建了一个包含2个线程的线程池，并提交了一个任务worker_func(5)。在任务完成后，回调函数callback_func会被自动调用。 需要注意的是，回调函数的参数是一个Future对象，可以通过Future对象的result()方法获取任务的返回值。如果任务发生异常，可以通过Future对象的exception()方法获取异常信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值