我目前正在用C ++编写素数生成器。我先制作了单线程版本，后来又制作了多线程版本。
我发现如果我的程序生成的值小于100'000，则单线程版本比多线程版本更快。显然我做错了。
我的代码如下：
#include <iostream>
#include <fstream>
#include <set>
#include <string>
#include <thread>
#include <mutex>
#include <shared_mutex>
using namespace std;
set<unsigned long long> primeContainer;
shared_mutex m;
void checkPrime(const unsigned long long p)
{
if (p % 3 == 0)
return;
bool isPrime = true;
for (set<unsigned long long>::const_iterator it = primeContainer.cbegin(); it != primeContainer.cend(); ++it)
{
if (p % *it == 0)
{
isPrime = false;
break;
}
if (*it * *it > p) // check only up to square root
break;
}
if (isPrime)
primeContainer.insert(p);
}
void checkPrimeLock(const unsigned long long p)
{
if (p % 3 == 0)
return;
bool isPrime = true;
try
{
shared_lock<shared_mutex> l(m);
for (set<unsigned long long>::const_iterator it = primeContainer.cbegin(); it != primeContainer.cend(); ++it)
{
if (p % *it == 0)
{
isPrime = false;
break;
}
if (*it * *it > p)
break;
}
}
catch (exception& e)
{
cout << e.what() << endl;
system("pause");
}
if (isPrime)
{
try
{
unique_lock<shared_mutex> l(m);
primeContainer.insert(p);
}
catch (exception& e)
{
cout << e.what() << endl;
system("pause");
}
}
}
void runLoopThread(const unsigned long long& l)
{
for (unsigned long long i = 10; i < l; i += 10)
{
thread t1(checkPrimeLock, i + 1);
thread t2(checkPrimeLock, i + 3);
thread t3(checkPrimeLock, i + 7);
thread t4(checkPrimeLock, i + 9);
t1.join();
t2.join();
t3.join();
t4.join();
}
}
void runLoop(const unsigned long long& l)
{
for (unsigned long long i = 10; i < l; i += 10)
{
checkPrime(i + 1);
checkPrime(i + 3);
checkPrime(i + 7);
checkPrime(i + 9);
}
}
void printPrimes(const unsigned long long& l)
{
if (1U <= l)
cout << "1 ";
if (2U <= l)
cout << "2 ";
if (3U <= l)
cout << "3 ";
if (5U <= l)
cout << "5 ";
for (auto it = primeContainer.cbegin(); it != primeContainer.cend(); ++it)
{
if (*it <= l)
cout << *it << " ";
}
cout << endl;
}
void writeToFile(const unsigned long long& l)
{
string name = "primes_" + to_string(l) + ".txt";
ofstream f(name);
if (f.is_open())
{
if (1U <= l)
f << "1 ";
if (2U <= l)
f << "2 ";
if (3U <= l)
f << "3 ";
if (5U <= l)
f << "5 ";
for (auto it = primeContainer.cbegin(); it != primeContainer.cend(); ++it)
{
if (*it <= l)
f << *it << " ";
}
}
else
{
cout << "Error opening file." << endl;
system("pause");
}
}
int main()
{
unsigned int n = thread::hardware_concurrency();
std::cout << n << " concurrent threads are supported." << endl;
unsigned long long limit;
cout << "Please enter the limit of prime generation: ";
cin >> limit;
primeContainer.insert(7);
if (10 < limit)
{
//runLoop(limit); //single-threaded
runLoopThread(limit); //multi-threaded
}
printPrimes(limit);
//writeToFile(limit);
system("pause");
return 0;
}
在main函数中，您将找到关于哪个函数是单线程和多线程的注释。
它们之间的主要区别在于使用锁，为容器迭代共享，以及插入时唯一。如果重要，我的CPU有4个核心。
为什么单线程版本更快？
答案 0 :(得分：11)
你有几个问题。
首先，你不必要地继续创建和销毁线程。让每个线程循环工作，直到没有更多的工作要做。
其次，您的锁方式太精细了，因此，您经常以方式获取它们。让每个线程抓住一个包含100个数字的块来进行测试，而不是一次一个，并让它们一次性从每个块中插入找到的素数。
答案 1 :(得分：4)
对我而言，似乎您正在为每个单一的素数检查开始一个新线程。那是不好的恕我直言，因为线程启动/关闭加上同步增加了每个素数的计算。启动一个线程可能会很慢。
我建议在主for循环之外启动那4个线程，并在每个线程中处理范围的1/4。但是这可能需要一些额外的同步，因为要检查一个素数，上面的代码显然需要首先得到可用的sqrt N的素数。
从我的角度来看，使用Sieve of Erastothenes算法可能更容易，在没有任何锁定的情况下可能更容易并行化（但是可能仍会遇到称为＆＃34的问题; {{3} }＆＃34;。）
修改
在这里，我使用Siera of Erastothenes快速创建了一个版本：
void processSieve(const unsigned long long& l,
const unsigned long long& start,
const unsigned long long& end,
const unsigned long long& step,
vector<char> &is_prime)
{
for (unsigned long long i = start; i <= end; i += step)
if (is_prime[i])
for (unsigned long long j = i + i; j <= l; j += i)
is_prime[j] = 0;
}
void runSieve(const unsigned long long& l)
{
vector<char> is_prime(l + 1, 1);
unsigned long long end = sqrt(l);
processSieve(l, 2, end, 1, is_prime);
primeContainer.clear();
for (unsigned long long i = 1; i <= l; ++i)
if (is_prime[i])
primeContainer.insert(i);
}
void runSieveThreads(const unsigned long long& l)
{
vector<char> is_prime(l + 1, 1);
unsigned long long end = sqrt(l);
vector<thread> threads;
threads.reserve(cpuCount);
for (unsigned long long i = 0; i < cpuCount; ++i)
threads.emplace_back(processSieve, l, 2 + i, end, cpuCount, ref(is_prime));
for (unsigned long long i = 0; i < cpuCount; ++i)
threads[i].join();
primeContainer.clear();
for (unsigned long long i = 1; i <= l; ++i)
if (is_prime[i])
primeContainer.insert(i);
}
测量结果，最高可达1 000 000（MSVC 2013，发布）：
runLoop: 204.02 ms
runLoopThread: 43947.4 ms
runSieve: 30.003 ms
runSieveThreads (8 cores): 24.0024 ms
最多10 0000 000：
runLoop: 4387.44 ms
// runLoopThread disabled, taking too long
runSieve: 350.035 ms
runSieveThreads (8 cores): 285.029 ms
时间包括矢量的最终处理并将结果推送到素数集。
正如您所看到的，即使在单线程版本中，Sieve版本也比您的版本快得多（对于您的互斥锁版本，我必须将锁更改为常规互斥锁，因为MSVC 2013没有shared_lock，因此结果是可能比你的差得多）。
但是你可以看到筛网的多线程版本运行速度仍然没有预期的那么快（8个核心，即8个线程，线性加速比单线程快8倍），虽然没有锁定（折衷了如果没有标记为＆＃34;没有素数＆＃34;其他线程，某些数字可能会不必要地运行，但一般来说结果应该是稳定的，因为每次只设置为0，如果同时设置为无关紧要多线程）。加速不是线性的原因很可能是因为＆＃34; false sharing＆＃34;我之前提到的问题 - 写入零的线程使每个其他缓存行无效。
答案 2 :(得分：2)
由于评论部分变得有点拥挤，OP表示对无锁解决方案感兴趣，我提供了以下这种方法的示例（半伪代码）：
vector<uint64_t> primes_thread1;
vector<uint64_t> primes_thread2;
...
// check all numbers in [start, end)
void check_primes(uint64_t start, uint64_t end, vector<uint64_t> & out) {
for (auto i = start; i < end; ++i) {
if (is_prime(i)) { // simply loop through all odds from 3 to sqrt(i)
out.push_back(i);
}
}
}
auto f1 = async(check_primes, 1, 1000'000, ref(primes_thread1));
auto f2 = async(check_primes, 1000'000, 2000'000, ref(primes_thread2));
...
f1.wait();
f2.wait();
...
primes_thread1.insert(
primes_thread1.begin(),
primes_thread2.cbegin(), primes_thread2.cend()
);
primes_thread1.insert(
primes_thread1.begin(),
primes_thread3.cbegin(), primes_thread3.cend()
);
...
// primes_thread1 contains all primes found in all threads
显然，通过参数化线程数和每个范围的大小，可以很好地重构这一点。我希望通过不首先分享任何状态来更清楚地说明避免锁定的概念。
答案 3 :(得分：2)
您的黄金测试可能还有其他问题。你永远不会将7作为除数进行测试。
此外，您的测试假设primeContainer已经包含10和被测试数字的sqare根之间的所有素数。如果您使用线程来填充容器，情况可能并非如此。
如果你在容器中填充的数字总是在增加（并且你的算法依赖于它），你可以使用std :: vector而不是std :: set来获得更好的性能。