Thread Priority
The System.Threading.Thread.Priority enumeration defines the priority
states of a thread that in turn determines how much processor time a thread gets
to execute. Every thread has a priority in the range between
ThreadPriority.Lowest to ThreadPriority.Highest.
Threads are executed based on their priority levels. High priority threads
always get
more processor time than their counterparts. By default, each
thread has priority Normal.
We need thread priority when multiple threads are simultaneously
active. The System.Threading.Thread.Priority enumeration consists of :
-
Highest :
A value specifying that the current thread can be scheduled before threads
with any other priority.
-
AboveNormal :
A value specifying that the current thread can be scheduled after threads
with Highest priority
and before those with Normal priority.
-
Normal :
A value specifying that the current thread can be scheduled after threads
with AboveNormal priority
and before those with BelowNormalpriority.
Note that threads have Normal priority
by default.
-
BelowNormal
A value specifying that the current thread can be scheduled after threads
with Normal priority
and before those with Lowest priority.
-
Lowest :
A value specifying that the current thread can be scheduled after threads
with any other priority.
The following syntax shows how to set the thread priority:
NewThread.priority =
ThreadPriority.Highest;
ThreadPriority.Highest property specifies
the new priority setting for a thread. Threads are scheduled for execution based
on their priority. If we have more than one high priority threads in this case.
Operating system cycles through the threads giving each high priority thread
some amount of processor time. Lower priority thread do not execute as long as
higher priority thread is available. If at any point it encounters a higher
priority thread, then the lower priority threads are preempted and give way to
the higher priority thread to execute. When there are no more threads of higher
priority, the operating system then selects the next lower priority threads for
execution.
Gets or sets a value indicating the scheduling priority of a thread.
In the following example we have two thread the priority of one thread is set to
BelowNormal.
Both threads increment a variable in a while loop
and run for a set time. Now we see how the
the
priority of a thread changing the result of the program.
using
System;
using
System.Threading;
namespace
threadpriority
{
class
PriorityTest
{
bool loopSwitch;
public PriorityTest()
{
loopSwitch = true;
}
public bool
LoopSwitch
{
set { loopSwitch =
value; }
}
public void
ThreadMethod()
{
long threadCount = 0;
while (loopSwitch)
{
threadCount++;
}
Console.WriteLine("{0}
with {1,11} priority " +
"has a count = {2,13}",
Thread.CurrentThread.Name,
Thread.CurrentThread.Priority.ToString(),
threadCount.ToString("N0"));
}
}
class
Akshay
{
static
void Main()
{
PriorityTest priorityTest =
new PriorityTest();
ThreadStart startDelegate =
new ThreadStart(priorityTest.ThreadMethod);
Thread threadOne =
new Thread(startDelegate);
threadOne.Name = "ThreadOne";
Thread threadTwo =
new Thread(startDelegate);
threadTwo.Name = "ThreadTwo";
threadTwo.Priority = ThreadPriority.BelowNormal;
threadOne.Start();
threadTwo.Start();
// Allow counting for 10 seconds.
Thread.Sleep(10000);
priorityTest.LoopSwitch = false;
Console.Read();
}
}
}
Output :
![thpri.gif]()
Note :
Exception
Handling
Exception handling is a technique
to handle the exception (run time error) in our program. The exception handling
is hard concept in case of threading.
In multi-threading the exceptions can not be
cross-thread accessed, they can only be caught from the thread which code is
running on. Any try/catch/finally blocks in scope when a thread is created are
of no relevance to the thread when it starts executing. Consider the following
program:
using
System;
using
System.Threading;
namespace
exception_in_thread
{
class Akshay
{
public static
void Main()
{
try
{
new
Thread(Run).Start();
}
catch (Exception
ex)
{
// We'll never get here!
Console.WriteLine("Exception!");
}
}
static void
Run()
{
throw null;
} // Throws a NullReferenceException
}
}
The try/catch statement in example above is
effectively useless, and the newly created thread will be encumbered with an
unhandled NullReferenceException .This
shows that every thread have a separate path of execution. The solution of this
problem is that every thread entry
methods to have their own exception handlers.
using
System;
using
System.Threading;
namespace
exception_in_thread
{
class akshay
{
public static
void Main()
{
new
Thread (Go).Start();
}
static
void Go()
{
try
{
...
throw
null; // The
NullReferenceException will get caught below
...
}
catch (Exception
ex)
{
Typically log the exception, and/or signal another thread
that we've come unstuck
...
}
}
}
Hence the conclusion is that all thread entry
method require a exception handler in application to avoid the exception. As we
know that An unhandled exception causes the whole application to shut down with
a ugly massage.