Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions
Privacy Policy




Thinking in C++ Vol 2 - Practical Programming
Prev Home Next


The priority of a thread conveys the importance of a thread to the scheduler. Although the order that the CPU runs a set of threads is indeterminate, the scheduler will lean toward running the waiting thread with the highest priority first. However, this doesn t mean that threads with lower priority aren t run (that is, you can t get deadlocked because of priorities). Lower priority threads just tend to run less often.

Here s MoreBasicThreads.cpp modified so that the priority levels are demonstrated. The priorities are adjusting by using Thread s setPriority( ) function.

//: C11:SimplePriorities.cpp
// Shows the use of thread priorities.
//{L} ZThread
#include <iostream>
#include "zthread/Thread.h"
using namespace ZThread;
using namespace std;
const double pi = 3.14159265358979323846;
const double e = 2.7182818284590452354;
class SimplePriorities : public Runnable {
int countDown;
volatile double d; // No optimization
int id;
SimplePriorities(int ident=0): countDown(5), id(ident) {}
~SimplePriorities() {
cout << id << " completed" << endl;
friend ostream&
operator<<(ostream& os, const SimplePriorities& sp) {
return os << "#" << << " priority: "
<< Thread().getPriority()
<< " count: "<< sp.countDown;
void run() {
while(true) {
// An expensive, interruptable operation:
for(int i = 1; i < 100000; i++)
d = d + (pi + e) / double(i);
cout << *this << endl;
if(--countDown == 0) return;
int main() {
try {
Thread high(new SimplePriorities);
for(int i = 0; i < 5; i++) {
Thread low(new SimplePriorities(i));
} catch(Synchronization_Exception& e) {
cerr << e.what() << endl;
} ///:~

Here, operator<<( ) is overridden to display the identifier, priority, and countDown value of the task.

You can see that the priority level of thread high is at the highest level, and all the rest of the threads are at the lowest level. We are not using an Executor in this example because we need direct access to the threads in order to set their priorities.

Inside SimplePriorities::run( ), 100,000 repetitions of a rather expensive floating-point calculation are performed, involving double addition and division. The variable d is volatile to try to ensure that no compilers optimizations are performed. Without this calculation, you don t see the effect of setting the priority levels. (Try it: comment out the for loop containing the double calculations.) With the calculation, you see that thread high is given a higher preference by the thread scheduler. (At least, this was the behavior on a Windows machine.) The calculation takes long enough that the thread scheduling mechanism jumps in, changes threads, and pays attention to the priorities so that thread high gets preference.

You can also read the priority of an existing thread with getPriority( ) and change it at any time (not just before the thread is run, as in SimplePriorities.cpp) with setPriority( ).

Mapping priorities to operating systems is problematic. For example, Windows 2000 has seven priority levels, while Sun s Solaris has 231 levels. The only portable approach is to stick to very large priority granulations, such as the Low, Medium, and High used in the ZThread library.

Thinking in C++ Vol 2 - Practical Programming
Prev Home Next

   Reproduced courtesy of Bruce Eckel, MindView, Inc. Design by Interspire