Thread.Priority Property (System.Threading)

Option Explicit
Option Strict

Imports System
Imports System.Threading

Public Class Test

    <MTAThread> _
    Shared Sub Main()
        Dim priorityTest As New PriorityTest()

        Dim threadOne As Thread = _
            New Thread(AddressOf priorityTest.ThreadMethod)
        threadOne.Name = "ThreadOne"
        Dim threadTwo As Thread = _
            New Thread(AddressOf priorityTest.ThreadMethod)
        threadTwo.Name = "ThreadTwo"

        threadTwo.Priority = ThreadPriority.BelowNormal
        threadOne.Start()
        threadTwo.Start()

        ' Allow counting for 10 seconds.
        Thread.Sleep(10000)
        priorityTest.LoopSwitch = False
    End Sub

End Class

Public Class PriorityTest

    Dim loopSwitchValue As Boolean 

    Sub New()
        loopSwitchValue = True
    End Sub

    WriteOnly Property LoopSwitch As Boolean
        Set
            loopSwitchValue = Value
        End Set
    End Property

    Sub ThreadMethod()
        Dim threadCount As Long = 0

        While loopSwitchValue
            threadCount += 1
        End While

        Console.WriteLine("{0} with {1,11} priority " & _
            "has a count = {2,13}", Thread.CurrentThread.Name, _
            Thread.CurrentThread.Priority.ToString(), _
            threadCount.ToString("N0")) 
    End Sub

End Class

using System;
using System.Threading;

class Test
{
    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;
    }
}

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")); 
    }
}

using namespace System;
using namespace System::Threading;
ref class PriorityTest
{
private:
   bool loopSwitch;

public:
   PriorityTest()
   {
      loopSwitch = true;
   }


   property bool LoopSwitch 
   {
      void set( bool value )
      {
         loopSwitch = value;
      }

   }
   void ThreadMethod()
   {
      __int64 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" ) );
   }

};

int main()
{
   PriorityTest^ priorityTest = gcnew PriorityTest;
   ThreadStart^ startDelegate = gcnew ThreadStart( priorityTest, &PriorityTest::ThreadMethod );
   Thread^ threadOne = gcnew Thread( startDelegate );
   threadOne->Name =  "ThreadOne";
   Thread^ threadTwo = gcnew Thread( startDelegate );
   threadTwo->Name =  "ThreadTwo";
   threadTwo->Priority = ThreadPriority::BelowNormal;
   threadOne->Start();
   threadTwo->Start();

   // Allow counting for 10 seconds.
   Thread::Sleep( 10000 );
   priorityTest->LoopSwitch = false;
}