【发布时间】：2011-06-20 18:52:32
【问题描述】：
我设计了一个类，它使用不同数量的线程用整数填充数组，以了解多线程的威力。但是根据我的结果，没有……
想法：想法过于用值“1”填充 100000000 个整数的数组。从 1 个线程开始（一个线程填充整个数组）并递增到 100 个线程（每个线程填充大小为 100000000/nbThreads 的子数组）
示例：使用 10 个线程，我创建了 10 个线程，每个线程填充 10000000 个整数的数组。
这是我的代码：
public class ThreadedArrayFilling extends Thread{
private int start;
private int partitionSize;
public static int[] data;
public static final int SIZE = 100000000;
public static final int NB_THREADS_MAX = 100;
public static void main(String[] args){
data = new int[SIZE];
long startTime, endTime;
int partition, startIndex, j;
ThreadedArrayLookup[] threads;
for(int i = 1; i <= NB_THREADS_MAX; i++){
startTime = System.currentTimeMillis();
partition = SIZE / i;
startIndex = 0;
threads = new ThreadedArrayLookup[i];
for(j = 0; j < i; j++){
threads[j] = new ThreadedArrayLookup(startIndex, partition);
startIndex += partition;
}
for(j = 0; j < i; j++){
try {
threads[j].join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
endTime = System.currentTimeMillis();
System.out.println(i + " THREADS: " + (endTime - startTime) + "ms");
}
}
public ThreadedArrayFilling(int start, int size){
this.start = start;
this.partitionSize = size;
this.start();
}
public void run(){
for(int i = 0; i < this.partitionSize; i++){
data[this.start + i] = 1;
}
}
public static String display(int[] d){
String s = "[";
for(int i = 0; i < d.length; i++){
s += d[i] + ", ";
}
s += "]";
return s;
}
}
这是我的结果：
1 THREADS: 196ms
2 THREADS: 208ms
3 THREADS: 222ms
4 THREADS: 213ms
5 THREADS: 198ms
6 THREADS: 198ms
7 THREADS: 198ms
8 THREADS: 198ms
9 THREADS: 198ms
10 THREADS: 206ms
11 THREADS: 201ms
12 THREADS: 197ms
13 THREADS: 198ms
14 THREADS: 204ms
15 THREADS: 199ms
16 THREADS: 203ms
17 THREADS: 234ms
18 THREADS: 225ms
19 THREADS: 235ms
20 THREADS: 235ms
21 THREADS: 234ms
22 THREADS: 221ms
23 THREADS: 211ms
24 THREADS: 203ms
25 THREADS: 206ms
26 THREADS: 200ms
27 THREADS: 202ms
28 THREADS: 204ms
29 THREADS: 202ms
30 THREADS: 200ms
31 THREADS: 206ms
32 THREADS: 200ms
33 THREADS: 205ms
34 THREADS: 203ms
35 THREADS: 200ms
36 THREADS: 206ms
37 THREADS: 200ms
38 THREADS: 204ms
39 THREADS: 205ms
40 THREADS: 201ms
41 THREADS: 206ms
42 THREADS: 200ms
43 THREADS: 204ms
44 THREADS: 204ms
45 THREADS: 206ms
46 THREADS: 203ms
47 THREADS: 204ms
48 THREADS: 204ms
49 THREADS: 201ms
50 THREADS: 205ms
51 THREADS: 204ms
52 THREADS: 207ms
53 THREADS: 202ms
54 THREADS: 207ms
55 THREADS: 207ms
56 THREADS: 203ms
57 THREADS: 203ms
58 THREADS: 201ms
59 THREADS: 206ms
60 THREADS: 206ms
61 THREADS: 204ms
62 THREADS: 201ms
63 THREADS: 206ms
64 THREADS: 202ms
65 THREADS: 206ms
66 THREADS: 205ms
67 THREADS: 207ms
68 THREADS: 210ms
69 THREADS: 207ms
70 THREADS: 203ms
71 THREADS: 207ms
72 THREADS: 205ms
73 THREADS: 203ms
74 THREADS: 211ms
75 THREADS: 202ms
76 THREADS: 207ms
77 THREADS: 204ms
78 THREADS: 212ms
79 THREADS: 203ms
80 THREADS: 210ms
81 THREADS: 206ms
82 THREADS: 205ms
83 THREADS: 203ms
84 THREADS: 203ms
85 THREADS: 209ms
86 THREADS: 204ms
87 THREADS: 206ms
88 THREADS: 208ms
89 THREADS: 263ms
90 THREADS: 216ms
91 THREADS: 230ms
92 THREADS: 216ms
93 THREADS: 230ms
94 THREADS: 234ms
95 THREADS: 234ms
96 THREADS: 217ms
97 THREADS: 229ms
98 THREADS: 228ms
99 THREADS: 215ms
100 THREADS: 232ms
我错过了什么？
编辑：附加信息：
我的机器运行的是双核。
期望：
- 我期待看到 1 到 2 个线程之间的性能大幅提升（以利用双核）
- 我还预计在此之后大量线程会出现减速。
但这并不能证实我的期望。我的期望是错误的，还是我的算法有问题？
【问题讨论】：
-
@nbarraille，你的机器有多少个内核？
-
“示例：有 10 个线程，我创建了 10 个线程，每个线程填充 10000000 个整数的数组。” - 我假设你的意思是每个线程都填充了数组的 1/10？
-
dsolimano：这台机器上有 2 个核心
-
@nbarraille，在修复了类和构造函数名称之间明显的不匹配之后，我已经在我的机器（2 个核心）上测试了你的代码，并且我在 2 个线程的性能上得到了相当显着的提升：800 1 线程毫秒，2 线程 500 毫秒。进一步增加并没有太大变化。
-
这个网站急需“如何写微基准？”和“缓存未命中到底是什么？”指南。
标签： java multithreading performance benchmarking