Threads run sequentially?

When running a program with multiple threads of execution, does windows grant them CPU time sequentially? So for example will the order of thread execution be:

Thread A
Thread B
Thread C
Thread A
Thread B
Thread C
Thread A
.......

Or is it random?

Thanks in advance

I believe Windows uses a variation of Shortest Job First with emphasis on priority scheduling algorithm.

Kuphryn

The best discription I have seen in books is a "round-robin" approach at its most basic (assuming all threads are equal).....so yeah in theory your model is close. But factors like thread priority distort this quite a bit (higher the priority, the greater the quantums they have)......and also add to the that hardware interupts are able to "jump the queue" above any priority level that you are able to set......

It's pretty unreliable sometimes. Often you'll see even threads with the same priority execute out of whack, and almost always you cannot count on threads launched side by side to start in perfect order. I really don't know why this is the case tho, your guess is as good as mine. If it's *really* important though, you should use global flags, locks, mutex's, etc...

Ok thanks guys.

Another question, I wasn't aware until now that it is possible to assign a priority to a thread. Is this done by using (from msdn):

Code:

---

BOOL SetPriorityClass(
  HANDLE hProcess,
  DWORD dwPriorityClass
);

---

where:

hProcess would be the name of the thread
dwPriorityClass would be for example HIGH_PRIORITY_CLASS (msdn)

Thanks again

On second thoughts, I just found this:

Code:

---

BOOL SetThreadPriority(
  HANDLE hThread,
  int nPriority
);

---

Which I assume is what I am actually after right?

Right.

And don't forget about GetThreadPriority(), SuspendThread() and ResumeThread().

Another useful function you'll need is GetExitCodeThread, especially for console programs. You can use it to hold the console window open while the thread is in action:

Code:

---


bool ThreadIsActive(HANDLE thread)
{
 DWORD status = 0;
 GetExitCodeThread(thread, &status);
    if(status == STILL_ACTIVE)
  {
    return true;
  }
 CloseHandle(thread);
 return false;
}

int main()
{
 //...code

 while(ThreadIsActive(thread))
  continue; // a busy loop
}

---

Doh!! I have been doing pretty much the same thing but manually. Having a global flag that the thread sets to 1 upon execution and 0 upon termination. Your method is much tidier I feel.

Thanks guys

Once, I studied this, check this document:
http://www.strandmark.com/arbeten/ai.pdf page 17

It's in Swedish, but the two graphs show how many instructions each of two threads (with equal priority and code) execute over time.