我建议不要给每个线程一个块A（1-100）和B（101-200），每个线程被分配一个模。例如，A将取所有奇数指数，B取所有偶数指数，得到A {1,3,5,7,9，...，191,193,195,197,199}和B {2,4,6,8，...， 190,192,194,196,198,200}。这可能是负载平衡线程的最快和最简单的方法，因为计算的复杂性将均匀分布。
下一个建议是添加一个bool指示是否可以继续处理。然后，在每次计算开始之前，检查是否可以继续。通过这种方式，您可以在不终止线程的情况下停止计算，但每次循环需要额外比较一次。
#include <windows.h>
#include <stdio.h>
#include <process.h>
#include <queue>
#include <cmath>
#include <iostream>
using namespace std;
bool run;
priority_queue<int> primes;
CRITICAL_SECTION critical;
struct args
{
int begin;
int end;
}par1, par2;
int e_prosto(int n)
{
for(int i = 2; i*i<(n + 1) ; i++)
if (n & 1 == 0 || n % i == 0) return 0;
return 1;
}
unsigned int __stdcall rabotnik(void* n)
{
struct args *lPar = (args*) n;
for(int i = lPar->begin; i < lPar->end && run; i++)
{
if(e_prosto(i)){
EnterCriticalSection(&critical);
primes.push(i);
LeaveCriticalSection(&critical);
}
}
run = false;
return 0;
}
int main()
{
int foo;
printf(" Tarsene na prosti do: ");
scanf("%d", &foo);
par1.begin=1;
par1.end=foo/2+1;
par2.begin=foo/2+1;
par2.end=foo;
run = true;
HANDLE hvadkaA, hvadkaB;
InitializeCriticalSection(&critical);
SYSTEMTIME st, now, then;
hvadkaA = (HANDLE)_beginthreadex(0, 0, &rabotnik, (void*)&par1, 0, 0);
hvadkaB = (HANDLE)_beginthreadex(0, 0, &rabotnik, (void*)&par2, 0, 0);
::GetSystemTime(&then);
WaitForSingleObject(hvadkaA, INFINITE);
WaitForSingleObject(hvadkaB, INFINITE);
CloseHandle(hvadkaA);
CloseHandle(hvadkaB);
::GetSystemTime(&now);
while(!primes.empty())
{
printf("%d \t", primes.top());
primes.pop();
}
printf("\nGotov za %d milisec", abs(now.wMilliseconds - then.wMilliseconds));
system("pause>nul");
return 0;
}
另一种方法是将您的范围分割成许多块，然后当一个线程完成时给它一个新的块来处理。这样做的好处是不会增加额外的计算开销，但确实需要更多的代码（因此，您正在重复使用线程并监听任何线程的完成，而不仅仅是一个）。要有任何价值，那么你可能需要更大的范围，你可能需要根据复杂性（块大小{1-100}，{101-150}，{151-175}，{176-183}）， {184-187}，...）。使用代码的快速示例（使用对称块大小）：
#include <windows.h>
#include <stdio.h>
#include <process.h>
#include <queue>
#include <cmath>
#include <iostream>
using namespace std;
priority_queue<int> primes;
CRITICAL_SECTION critical;
typedef struct args
{
int begin;
int end;
//Helper method for initalizing struct
void setAll(int inBegin, bool inEnd)
{
}
} *PArgs;
int e_prosto(int n)
{
for(int i = 2; i*i<(n + 1) ; i++)
if (n & 1 == 0 || n % i == 0) return 0;
return 1;
}
static DWORD WINAPI rabotnik(LPVOID lpParam)
{
struct args *lPar = (args*) lpParam;
for(int i = lPar->begin; i < lPar->end; i++)
{
if(e_prosto(i)){
EnterCriticalSection(&critical);
primes.push(i);
LeaveCriticalSection(&critical);
}
}
return 0;
}
int main()
{
const int NUM_THREAD = 2; //Use named constant incase you want to change later.
DWORD returnedThreadID;
DWORD threadID[NUM_THREAD];
HANDLE threadHandle[NUM_THREAD]; //Holds the handels for the threads.
int foo, //Range size.
fooBlockSize, //Number of elements in a block.
nextBlock;
PArgs par[NUM_THREAD];
printf(" Tarsene na prosti do: ");
scanf("%d", &foo); //Get range size from user.
fooBlockSize = foo/(NUM_THREAD * 10); //Set number of elements in a block.
InitializeCriticalSection(&critical);
SYSTEMTIME st, now, then;
for (int i = 0; i < NUM_THREAD; i++)
{
par[i] = (PArgs) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PArgs));
// If the allocation fails, the system is out of memory so terminate execution.
if(par[i] == NULL){ cout<<"par HeapAlloc failed with error# "<<GetLastError()<<endl<<"Will now quit."<<endl; ExitProcess(2);}
}
for(int i = 0; i < NUM_THREAD; i++)
{
par[i]->begin = (fooBlockSize * i) + 1;
par[i]->end = par[i]->begin + fooBlockSize;
threadHandle[i] = CreateThread(NULL, 0, rabotnik, par[i], CREATE_SUSPENDED, &threadID[i]);
}
nextBlock = NUM_THREAD;
::GetSystemTime(&then);
for (int i = 0; i < NUM_THREAD; i++)
{
ResumeThread(threadHandle[i]); //Start threads
}
while(((fooBlockSize * nextBlock) + 1) < foo)
{
returnedThreadID = WaitForMultipleObjects(NUM_THREAD, threadHandle, false, INFINITE); //Wait for a thread to complete.
for(int i = 0; i<NUM_THREAD;i++)
{
if(returnedThreadID = threadID[i])
{
//Update the thread's arguments with the new block.
par[i]->begin = (fooBlockSize * nextBlock) + 1;
par[i]->end = par[i]->begin + fooBlockSize;
//Restart the thread.
ResumeThread(threadHandle[i]);
nextBlock++;
}
}
}
for (int i = 0; i < NUM_THREAD; i++)
{
//Return heap memorry (good practice, though Windows should return it all when the process terminates).
if (HeapFree(GetProcessHeap(), 0, par[i]) == 0)
{
cout<<"HeapFree failed for par["<<i<<"]"<<endl;
}
//Not sure we need to close the threads, but it was in original version.
CloseHandle(threadHandle[i]);
}
::GetSystemTime(&now);
while(!primes.empty())
{
printf("%d \t", primes.top());
primes.pop();
}
printf("\nGotov za %d milisec", abs(now.wMilliseconds - then.wMilliseconds));
system("pause>nul");
return 0;
}
在增加块数与块大小之间有一个折衷。增加块的数量意味着只有一个块能够处理的时间会更少（线程[0]完成，并且在线程[1]结束时没有剩下任何处理），但也意味着将会有我花了更多时间等待调度程序循环分配一个新块来处理。用你的问题陈述，我期望找到更高级别的素数需要很长时间，这并不重要。
正如其他答案所指出的，不要使用相同的堆栈来存储每个线程找到的主要值（工作锁所需的时间过长）。如果你想以数字顺序返回素数，我建议重写打印素数的循环，以便它同时通过两个堆栈，打印下一个值（按顺序）。有些东西，如：
while(!primes1.empty() && !primes2.empty())
{
if(primes1.top() > primes2.top())
{
printf("%d \t", primes1.top());
primes1.pop();
}
else
{
printf("%d \t", primes2.top());
primes2.pop();
}
}
你将不得不应对一个堆遗留下来的价值观一旦另一个是空的（或者放置一个-1在每个堆栈的底部，所以，如果你要么堆栈为空，则所有大于-1的值都将被打印）。
另一种解决方案是维护每次线程返回时更新的素数的排序列表。然后可以将其复制到par结构中，以便更快地进行主要检测（如果某个数字可以被现有的素数均匀分配，则该数字不是素数）。
注：我没有测试过这些例子，尽管它们应该足够接近以给你一般的想法。
为每个线程设置一个作业队列会更有意义。杀死/终止短线程，特别是对于主要发现听起来像是一个非常糟糕的主意。你是否仅仅将它作为线程练习？ – 2012-02-27 22:59:36
是的，我今天只是看着线程，这是一个练习 – 2012-02-27 23:06:50
运行一个多线程筛看起来似乎是一个更有趣的练习。 – 2012-02-27 23:39:21