我想知道可以运行的最佳线程数。通常，这等于
然而，在支持超线程的CPU上，返回的数字会高出一倍。现在，对于某些任务，超线程是有好处的，但对于其他任务则无用。在我的情况下，我怀疑它没有用，所以我想知道是否需要将
为此，我必须推断出CPU是否支持超线程。因此，我的问题是 - 如何在Java中实现？
谢谢。
编辑
好的，我已经对我的代码进行了基准测试。以下是我的环境：
请查看以下结果（我稍微更改了输出以省略重复部分）：
Runtime.getRuntime().availableProcessors()。然而，在支持超线程的CPU上，返回的数字会高出一倍。现在，对于某些任务，超线程是有好处的，但对于其他任务则无用。在我的情况下，我怀疑它没有用，所以我想知道是否需要将
Runtime.getRuntime().availableProcessors()返回的数字除以二。为此，我必须推断出CPU是否支持超线程。因此，我的问题是 - 如何在Java中实现？
谢谢。
编辑
好的，我已经对我的代码进行了基准测试。以下是我的环境：
- 联想ThinkPad W510（即i7 CPU，带有4个内核和超线程），16G的RAM
- Windows 7
- 84个压缩的CSV文件，压缩大小从105M到16M不等
- 所有文件都在主线程中一个接一个地读取 - 没有多线程访问硬盘。
- 每个CSV文件行包含一些数据，解析数据并进行快速无上下文测试以确定该行是否相关。
- 每个相关行包含两个双精度浮点数（表示经度和纬度），这些数被强制转换为单个
Long，然后存储在共享哈希集合中。
因此，工作线程不会从硬盘读取任何内容，但它们会忙于解压缩和解析内容（使用opencsv库）。
以下是代码，没有无聊的细节：
public void work(File dir) throws IOException, InterruptedException {
Set<Long> allCoordinates = Collections.newSetFromMap(new ConcurrentHashMap<Long, Boolean>());
int n = 6;
// NO WAITING QUEUE !
ThreadPoolExecutor exec = new ThreadPoolExecutor(n, n, 0L, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());
StopWatch sw1 = new StopWatch();
StopWatch sw2 = new StopWatch();
sw1.start();
sw2.start();
sw2.suspend();
for (WorkItem wi : m_workItems) {
for (File file : dir.listFiles(wi.fileNameFilter)) {
MyTask task;
try {
sw2.resume();
// The only reading from the HD occurs here:
task = new MyTask(file, m_coordinateCollector, allCoordinates, wi.headerClass, wi.rowClass);
sw2.suspend();
} catch (IOException exc) {
System.err.println(String.format("Failed to read %s - %s", file.getName(), exc.getMessage()));
continue;
}
boolean retry = true;
while (retry) {
int count = exec.getActiveCount();
try {
// Fails if the maximum of the worker threads was created and all are busy.
// This prevents us from loading all the files in memory and getting the OOM exception.
exec.submit(task);
retry = false;
} catch (RejectedExecutionException exc) {
// Wait for any worker thread to finish
while (exec.getActiveCount() == count) {
Thread.sleep(100);
}
}
}
}
}
exec.shutdown();
exec.awaitTermination(1, TimeUnit.HOURS);
sw1.stop();
sw2.stop();
System.out.println(String.format("Max concurrent threads = %d", n));
System.out.println(String.format("Total file count = %d", m_stats.getFileCount()));
System.out.println(String.format("Total lines = %d", m_stats.getTotalLineCount()));
System.out.println(String.format("Total good lines = %d", m_stats.getGoodLineCount()));
System.out.println(String.format("Total coordinates = %d", allCoordinates.size()));
System.out.println(String.format("Overall elapsed time = %d sec, excluding I/O = %d sec", sw1.getTime() / 1000, (sw1.getTime() - sw2.getTime()) / 1000));
}
public class MyTask<H extends CsvFileHeader, R extends CsvFileRow<H>> implements Runnable {
private final byte[] m_buffer;
private final String m_name;
private final CoordinateCollector m_coordinateCollector;
private final Set<Long> m_allCoordinates;
private final Class<H> m_headerClass;
private final Class<R> m_rowClass;
public MyTask(File file, CoordinateCollector coordinateCollector, Set<Long> allCoordinates,
Class<H> headerClass, Class<R> rowClass) throws IOException {
m_coordinateCollector = coordinateCollector;
m_allCoordinates = allCoordinates;
m_headerClass = headerClass;
m_rowClass = rowClass;
m_name = file.getName();
m_buffer = Files.toByteArray(file);
}
@Override
public void run() {
try {
m_coordinateCollector.collect(m_name, m_buffer, m_allCoordinates, m_headerClass, m_rowClass);
} catch (IOException e) {
e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.
}
}
}
请查看以下结果（我稍微更改了输出以省略重复部分）：
Max concurrent threads = 4
Total file count = 84
Total lines = 56395333
Total good lines = 35119231
Total coordinates = 987045
Overall elapsed time = 274 sec, excluding I/O = 266 sec
Max concurrent threads = 6
Overall elapsed time = 218 sec, excluding I/O = 209 sec
Max concurrent threads = 7
Overall elapsed time = 209 sec, excluding I/O = 199 sec
Max concurrent threads = 8
Overall elapsed time = 201 sec, excluding I/O = 192 sec
Max concurrent threads = 9
Overall elapsed time = 198 sec, excluding I/O = 186 sec
你可以得出自己的结论，但我的结论是，在我的具体情况下，超线程确实提高了性能。此外，对于这个任务和我的机器来说，拥有6个工作线程似乎是正确的选择。