java操作xml运行速度慢?为啥呢?

Posted 2023-04-13

我最近写了一排课算法!是用dom4j包操作xml,用xml存储数据,发现在排课的时候好慢,我排一个班级差不多就一分钟了.若一个学校60个班就要一个小时了,这样老师是肯定等不来的...

请各位有经验之士发表下高见,难道是我的算法复杂呢?我觉得也并不复杂!
贴上源码!你们也没精神来看的!

贴不上去.?

看来还是得少操作xml文件,每操作一次就增加了运行时间

不会吧
我从saxReader = new SAXReader();到读取打印结束也不到1秒啊
读取的源码贴出来
或者QQ：25111337 参考技术A dom本来就慢
它好像是读一行解析一行 参考技术B 怎么写的 把源程序贴上来

有人可以解释为啥使用 OpenMP 部分的运行速度比单线程慢吗？

【中文标题】有人可以解释为啥使用 OpenMP 部分的运行速度比单线程慢吗？

【英文标题】：Can someone explain why using OpenMP sections run slower than a single thread?有人可以解释为什么使用 OpenMP 部分的运行速度比单线程慢吗？

【发布时间】：2017-08-23 20:18:31

【问题描述】：

我是并行编程的新手。 根据示例代码，有人可以解释为什么使用 OpenMP 部分的运行速度比单线程慢吗？有什么改进的建议吗？

#include<iostream>
#include <vector>
#include <chrono>
#include <numeric>
#include<omp.h>

using namespace std;

int Calculation_1(int A, int B);
int Calculation_2(int A, int B);
int Calculation_3(int A, int B);
int Calculation_4(int A, int B);

int main() 

vector<int>W;
vector<int>X;
vector<int>Y;
vector<int>Z;

chrono::steady_clock::time_point begin1 = std::chrono::steady_clock::now();
    omp_set_num_threads(4);

    #pragma omp parallel
    
    #pragma omp sections nowait
        
        #pragma omp section
            
                W.push_back(Calculation_1(5, 5));
            
        #pragma omp section
            
                X.push_back(Calculation_2(5, 5));
            
        #pragma omp section
            
                Y.push_back(Calculation_3(5, 5));
            
        #pragma omp section
            
                Z.push_back(Calculation_4(5, 5));
            
        
    

cout << "Parallel = " << accumulate(W.begin(), W.end(), 0) + accumulate(X.begin(), X.end(), 0) + accumulate(Y.begin(), Y.end(), 0) + accumulate(Z.begin(), Z.end(), 0) << endl;;
chrono::steady_clock::time_point end1 = std::chrono::steady_clock::now();
cout << "Time difference = " << std::chrono::duration_cast<std::chrono::nanoseconds>(end1 - begin1).count() << std::endl;
//Clear vector
W.clear();
X.clear();
Y.clear();
Z.clear();

////Sigle
chrono::steady_clock::time_point begin2 = std::chrono::steady_clock::now();

    W.push_back(Calculation_1(5, 5));
    X.push_back(Calculation_2(5, 5));
    Y.push_back(Calculation_3(5, 5));
    Z.push_back(Calculation_4(5, 5));

cout << "single = " << accumulate(W.begin(), W.end(), 0) + accumulate(X.begin(), X.end(), 0) + accumulate(Y.begin(), Y.end(), 0) + accumulate(Z.begin(), Z.end(), 0) << endl;
chrono::steady_clock::time_point end2 = std::chrono::steady_clock::now();
cout << "Time difference = " << std::chrono::duration_cast<std::chrono::nanoseconds>(end2 - begin2).count() << std::endl;

cin.get();

return 0;



int Calculation_1(int A, int B) 
    return A + B;

int Calculation_2(int A, int B) 
    return A + B;

int Calculation_3(int A, int B) 
    return A + B;

int Calculation_4(int A, int B) 
    return A + B;

结果是： 并行 = 40 时间 = 9168172

单人 = 40 时间225580

并行的比单一的慢 40 倍。

//我也尝试根据建议将许多数字推入向量中（代码如下）。结果是：（并行的比单一的慢9倍。）。

平行 时间 = 12907862

单人 时间 = 1334519

chrono::steady_clock::time_point begin1 = std::chrono::steady_clock::now();
    omp_set_num_threads(2);

    #pragma omp parallel
    
    #pragma omp sections nowait
        
        #pragma omp section
            
                for (int i = 0; i < 100000; i++) 
                    X.push_back(i);
                
            
        #pragma omp section
            
                for (int j = 0; j < 100000; j++) 
                    Y.push_back(j);
                
            
        
    

cout << "Parallel = " << accumulate(X.begin(), X.end(), 0) + accumulate(Y.begin(), Y.end(), 0) << endl;;
chrono::steady_clock::time_point end1 = std::chrono::steady_clock::now();
cout << "Time difference = " << std::chrono::duration_cast<std::chrono::nanoseconds>(end1 - begin1).count() << std::endl;
//Clear vector
X.clear();
Y.clear();

////Sigle
chrono::steady_clock::time_point begin2 = std::chrono::steady_clock::now();

for (int i = 0; i < 100000; i++) 
    X.push_back(i);

for (int j = 0; j < 100000; j++) 
    Y.push_back(j);



cout << "single = " << accumulate(X.begin(), X.end(), 0) + accumulate(Y.begin(), Y.end(), 0) << endl;
chrono::steady_clock::time_point end2 = std::chrono::steady_clock::now();
cout << "Time difference = " << std::chrono::duration_cast<std::chrono::nanoseconds>(end2 - begin2).count() << std::endl;

非常感谢，

【问题讨论】：

您的目标环境中有多少个内核可用？除非你有不同的 CPU 内核来处理它们，否则向线程扔东西并不会让它们神奇地更快。

启动线程是有代价的。你看到的就是这个成本。尝试添加循环以将许多项添加到向量中，看看效果如何，而不是添加单个项（这会浪费线程）

@Nathan 这应该是一个答案。如果 OP 进一步澄清他们的目标，让我们稍等一下。

让您的计算不仅仅是一个可能已经优化的加法。创建线程的成本远高于您在线程中执行的操作。

【参考方案1】：

还要注意，对于这种简单的计算，向线程发送垃圾邮件 的时间成本可能比仅在单个线程中计算它们的成本更大。 同样正如 user0042 所说，如果您的计算机垃圾邮件多于内核，他们将开始调度资源（内核）并共享它们，进入和退出也会减慢计算。

【参考方案2】：

要真正并行计算事物（运行彼此独立的线程），您需要有与线程相关联的专用 CPU 内核。

如果您的线程数多于可用的 CPU 内核数，您只会引入有关线程创建和调度的开销。这很可能是您的代码变慢的原因。

【讨论】：

您可以添加一些并行效率图来演示。

@Mel 好吧，不：-D。随意自己做（编辑我的答案或发布你自己的）。

哈哈也许明天！ :)