java - 在java中使用多线程时性能降低

Question

我是多线程新手，我必须使用多线程编写程序以提高其效率。在我的第一次尝试中，我所写的结果恰恰相反。这是我写的:

class ThreadImpl implements Callable<ArrayList<Integer>> { 
    //Bloom filter instance for one of the table
    BloomFilter<Integer> bloomFilterInstance = null;
    // Data member for complete data access.
    ArrayList< ArrayList<UserBean> > data = null;
    // Store the result of the testing 
    ArrayList<Integer> result = null;
    int tableNo;

    public ThreadImpl(BloomFilter<Integer> bloomFilterInstance, 
                        ArrayList< ArrayList<UserBean> > data, int tableNo) {
        this.bloomFilterInstance = bloomFilterInstance;
        this.data = data;
        result  = new ArrayList<Integer>(this.data.size());
        this.tableNo = tableNo;
    }

    public ArrayList<Integer> call() {
        int[] tempResult = new int[this.data.size()];
        for(int i=0; i<data.size() ;++i) {
            tempResult[i] = 0;
        }
        ArrayList<UserBean> chkDataSet = null;
        for(int i=0; i<this.data.size(); ++i) {
            if(i==tableNo) {
                //do nothing;
            } else {
                chkDataSet = new ArrayList<UserBean> (data.get(i));
                for(UserBean toChk: chkDataSet) {
                    if(bloomFilterInstance.contains(toChk.getUserId())) {
                        ++tempResult[i];
                    }
                }
            }
            this.result.add(new Integer(tempResult[i]));
        }
        return result;
    }
}

在上面的类中有两个数据成员data和bloomFilterInstance，它们(引用)是从主程序传递的。所以实际上只有一个 data 和bloomFilterInstance 实例，并且所有线程都在同时访问它。

启动线程的类是(省略了一些不相关的细节，因此所有变量等，您可以假设它们已被声明):

class MultithreadedVrsion {
    public static void main(String[] args) {
        if(args.length > 1) {
            ExecutorService es = Executors.newFixedThreadPool(noOfTables);
            List<Callable<ArrayList<Integer>>> threadedBloom = new ArrayList<Callable<ArrayList<Integer>>>(noOfTables);
            for (int i=0; i<noOfTables; ++i) {
                threadedBloom.add(new ThreadImpl(eval.bloomFilter.get(i), 
                                                eval.data, i)); 
            }
            try {
                List<Future<ArrayList<Integer>>> answers = es.invokeAll(threadedBloom);
                long endTime = System.currentTimeMillis();
                System.out.println("using more than one thread for bloom filters: " + (endTime - startTime) + " milliseconds");
                System.out.println("**Printing the results**");
                for(Future<ArrayList<Integer>> element: answers) {
                    ArrayList<Integer> arrInt = element.get();
                    for(Integer i: arrInt) {
                        System.out.print(i.intValue());
                        System.out.print("\t");
                    }
                    System.out.println("");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

我使用 jprofiler 进行了分析，

![此处]:(http://tinypic.com/r/wh1v8p/6)

是CPU线程的快照，其中红色显示阻塞，绿色显示可运行，黄色显示等待。我的问题是线程一次运行一个我不知道为什么？

注意:我知道这不是线程安全的，但我知道我现在只会执行读取操作，只是想分析可以实现的原始性能增益，稍后我将实现更好的版本。

Answer 1

Can anyone please tell where I have missed

一种可能性是创建线程的成本淹没了并行计算可能带来的性能增益。我们无法真正判断这是否真的有可能，因为您没有在问题中包含相关代码。

另一种可能性是您只有一个可用的处理器/内核。线程仅在有处理器运行时才运行。因此，您对线性速度与线程数量的期望只有在每个线程都有一个空闲处理器的情况下才可能实现(理论上)。

最后，由于线程都试图访问共享数组，可能会出现内存争用。如果您进行了适当的同步，则可能会增加进一步的争用。 (注意:我没有尝试理解该算法来确定您的示例中是否可能存在争用。)

<小时/>

我最初的建议是分析您的代码，看看是否能提供任何见解。

并检查一下您衡量性能的方式，以确保您看到的不仅仅是一些基准测试制品；而是您看到的。例如JVM 预热效果。