blocks|key|1712020|text|如果您的应用程序具有很好的伸缩性，那么在比较相同架构的机器时，您可以假定用于比较的处理能力是speed+*+cores。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1712021|基于这些假设，您的吞吐量可能与|1712022|1712023|4+*+2.53+=+10.12|unordered-list-item|1712024|6+*+2.4+=+14.4|1712025|1712026|6核系统的吞吐量最高可提高40%25。|1712027|但是，为了比较相似但不相同架构的CPU，我建议您查看CPU的SPEC_int_rate或SPEC_fp_rate。(仅在浮点密集时才使用后者，如果不确定，则不使用后者;)|1712028|entityMap|0|LINK|mutability|MUTABLE|url|http://www.spec.org/cpu2006/results/rint2006.html^0|1A|D|0|0|0|0|0|0|0|U|D|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|15|8|@]|D|@]|E|$]]|$1|L|3|M|5|K|7|16|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|17|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|18|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|19|8|@]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|S|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

If your application scales well, you can assume your processing power for comparison purposes is <code>speed * cores</code> when comparing machines of the same architecture.

Based on those assumptions, your throughput is likely to be proportional to

<ul>
<li>4 * 2.53 = 10.12</li>
<li>6 * 2.4 = 14.4</li>
</ul>

The 6 core system could have up to 40% higher throughput.

However for comparing CPU's of similar but not the same architecture I suggest you look at <a href="http://www.spec.org/cpu2006/results/rint2006.html" rel="nofollow">SPEC_int_rate</a> or SPEC_fp_rate for your CPUs. (Only use the latter if its floating point intensive, if in doubt, its not ;)

blocks|key|1711838|text|既然你说“大量多线程”，我会说更多的核心是首选。更高的时钟速度将意味着线程更快的上下文切换。如果你的算法是并行化的，我会说更多的核心会给你带来更大的提升。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1711839|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Since you said "heavily multi-threaded", I'd say that more cores are preferred. Higher clock speeds will just mean faster context switching for threads. If your algorithms are parallelized, I'd say more cores will give you a greater boost.

blocks|key|94038|text|如果您的应用程序当前是CPU受限的，并且如果很容易增加执行计算工作的并行线程的数量(即它们之间的依赖性最小)，那么您将从增加内核数量中受益。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|94039|如果这两个都不是真的(例如，如果您的大多数线程都用于处理磁盘、网络或用户IO)，那么无论哪种方式，您都看不到太多好处。|94040|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If your application is currently CPU-bound, and if it is easy to increase the number of parallel threads that are doing computational work (i.e. there's minimal dependencies between them), then you will benefit from increasing the number of cores.

If neither of these is true (for instance, if most of your threads are for handling disk, network or user IO), you won't see much benefit either way.

blocks|key|2212965|text|这取决于任务的性质。如果任务本质上是串行的(“任务1必须在任务2之前完成，任务2必须在任务3之前完成”，等等)如果任务可以并行执行(“任务1、2和3之间不使用数据，任务4整理结果”)，则核心计数更重要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2212966|换句话说，这完全取决于处理器的用途。|2212967|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

It depends on the nature of the tasks. If the tasks are serial in nature ("task 1 must be accomplished before task 2, task 2 must be accomplished before task 3," etc.) then processor speed is going to win; if the tasks can be executed in parallel ("tasks 1, 2, and 3 do not use data between them, and task 4 collates the results") then core count is more important. 

In other words, it depends entirely on what the processors are being used for.

blocks|key|1711967|text|2.53/2.4+=+1.05|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1711968|6/4+=+1.5|1711969|如果线程之间是相对独立的--在一个服务器应用程序中，一个池中只有一堆线程，并且每个线程都在客户端的下一个请求中给出--那么答案是显而易见的。|1711970|entityMap^0|0|F|0|0|9|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

<code>2.53/2.4 = 1.05</code>

<code>6/4 = 1.5</code>

If the threads are relatively independent of each other - which is definitely the case in a server app where there's just a bunch of threads in a pool, and each of them is given in the next request from client - then the answer is indeed obvious.

For heavily multi-threaded Java server app, what would be more recommended, having more CPU cores (6 instead of 4), or higher CPU frequency (2.53 Ghz instead of 2.4 Ghz).

It seems to me that it obvious more cores is the way to go, but I would like to hear a second opinion.

Thanks.

More cores VS more frequency for Java

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

对于大量多线程的Java服务器应用程序，更推荐使用更多的CPU核心(6个而不是4个)，或者更高的CPU频率(2.53 Ghz而不是2.4 Ghz)。在我看来，显然更多的核心是要走的路，但我想听听另一种意见。谢谢。

问更多的内核与更频繁的Java
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问更多的内核与更频繁的JavaEN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问更多的内核与更频繁的Java
EN