ThreadPriority Sabit listesi

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kod:

System.Threading.Thread.dll

Bütünleştirilmiş Kod:

mscorlib.dll

Bütünleştirilmiş Kod:

netstandard.dll

Zamanlama Threadönceliğini belirtir.

public enum class ThreadPriority

public enum ThreadPriority

[System.Serializable]
public enum ThreadPriority

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum ThreadPriority

type ThreadPriority = 

[<System.Serializable>]
type ThreadPriority = 

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ThreadPriority = 

Public Enum ThreadPriority

Devralma

Object

ValueType

Enum

ThreadPriority

Öznitelikler

SerializableAttribute ComVisibleAttribute

Alanlar

AboveNormal	3	Thread önceliğe sahip Highest iş parçacıklarından sonra ve önceliğe sahip Normal iş parçacıklarından önce zamanlanabilir.
BelowNormal	1	Thread önceliğe sahip Normal iş parçacıklarından sonra ve önceliğe sahip Lowest iş parçacıklarından önce zamanlanabilir.
Highest	4	, Thread başka bir önceliğe sahip iş parçacıklarından önce zamanlanabilir.
Lowest	0	başka Thread bir önceliğe sahip iş parçacıklarından sonra zamanlanabilir.
Normal	2	Thread önceliğe sahip AboveNormal iş parçacıklarından sonra ve önceliğe sahip BelowNormal iş parçacıklarından önce zamanlanabilir. İş parçacıkları varsayılan olarak önceliğe sahiptir Normal .

Örnekler

Aşağıdaki kod örneği, bir iş parçacığının önceliğini değiştirmenin sonucunu gösterir. Üç iş parçacığı oluşturulur, bir iş parçacığının önceliği BelowNormal, saniyenin önceliği ise AboveNormal olarak ayarlanır. Her iş parçacığı bir while döngüdeki değişkeni artırır ve belirli bir süre için çalışır.

using System;
using System.Threading;
using Timers = System.Timers;

class Test
{
    static void Main()
    {
        PriorityTest priorityTest = new PriorityTest();

        Thread thread1 = new Thread(priorityTest.ThreadMethod);
        thread1.Name = "ThreadOne";
        Thread thread2 = new Thread(priorityTest.ThreadMethod);
        thread2.Name = "ThreadTwo";
        thread2.Priority = ThreadPriority.BelowNormal;
        Thread thread3 = new Thread(priorityTest.ThreadMethod);
        thread3.Name = "ThreadThree";
        thread3.Priority = ThreadPriority.AboveNormal;

        thread1.Start();
        thread2.Start();
        thread3.Start();
        // Allow counting for 10 seconds.
        Thread.Sleep(10000);
        priorityTest.LoopSwitch = false;
    }
}

class PriorityTest
{
    static volatile bool loopSwitch;
    [ThreadStatic] static long threadCount = 0;

    public PriorityTest()
    {
        loopSwitch = true;
    }

    public bool LoopSwitch
    {
        set{ loopSwitch = value; }
    }

    public void ThreadMethod()
    {
        while(loopSwitch)
        {
            threadCount++;
        }
        Console.WriteLine("{0,-11} with {1,11} priority " +
            "has a count = {2,13}", Thread.CurrentThread.Name, 
            Thread.CurrentThread.Priority.ToString(), 
            threadCount.ToString("N0")); 
    }
}
// The example displays output like the following:
//    ThreadOne   with      Normal priority has a count =   755,897,581
//    ThreadThree with AboveNormal priority has a count =   778,099,094
//    ThreadTwo   with BelowNormal priority has a count =     7,840,984

Imports System.Threading
Imports Timers = System.Timers

Public Module Example
   Dim t As Timers.Timer
   Private priorityTest As New PriorityTest()

    Public Sub Main()
        Dim thread1 As New Thread(AddressOf priorityTest.ThreadMethod)
        thread1.Name = "ThreadOne"
        Dim thread2 As New Thread(AddressOf priorityTest.ThreadMethod)
        thread2.Name = "ThreadTwo"
        thread2.Priority = ThreadPriority.BelowNormal
        Dim thread3 As New Thread(AddressOf priorityTest.ThreadMethod)
        thread3.Name = "ThreadThree"
        thread3.Priority = ThreadPriority.AboveNormal
        thread1.Start()
        thread2.Start()
        thread3.Start()

        ' Allow threads to execute for about 10 seconds.
        t = New Timers.Timer()
        t.AutoReset = False
        t.Interval = 10000
        AddHandler t.Elapsed, AddressOf Elapsed
        t.Start()
    End Sub

    Private Sub Elapsed(sender As Object, e As Timers.ElapsedEventArgs)
       priorityTest.LoopSwitch = False
    End Sub
End Module

Public Class PriorityTest
    Private Shared loopSwitchValue As Boolean
    <ThreadStatic> Shared threadCount As Long

    Sub New()
        loopSwitchValue = True
    End Sub

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

    Sub ThreadMethod()
        Do While True
            threadCount += 1
            If Not loopSwitchValue Then Exit Do
        Loop

        Console.WriteLine("{0,-11} with {1,11} priority " &
            "has a count = {2,13}", Thread.CurrentThread.Name,
            Thread.CurrentThread.Priority.ToString(),
            threadCount.ToString("N0")) 
    End Sub
End Class
' The example displays the following output:
'    ThreadOne   with      Normal priority has a count =   755,897,581
'    ThreadThree with AboveNormal priority has a count =   778,099,094
'    ThreadTwo   with BelowNormal priority has a count =     7,840,984

Açıklamalar

ThreadPriority bir iş parçacığı önceliği için tüm olası değerlerin kümesini tanımlar. İş parçacığı öncelikleri, bir iş parçacığının diğerinin göreli önceliğini belirtir.

Her iş parçacığının atanmış bir önceliği vardır. Çalışma zamanı içinde oluşturulan iş parçacıklarına başlangıçta öncelik atanırken Normal , çalışma zamanı dışında oluşturulan iş parçacıkları çalışma zamanına girdiklerinde önceki önceliklerini korur. Bir iş parçacığının özelliğine erişerek Priority önceliğini alabilir ve ayarlayabilirsiniz.

İş parçacıkları, önceliklerine göre yürütülmeye zamanlanır. İş parçacığı yürütme sırasını belirlemek için kullanılan zamanlama algoritması her işletim sistemine göre değişir. Kullanıcı arabiriminin odağı ön plan ile arka plan arasında taşındığından işletim sistemi iş parçacığı önceliğini dinamik olarak da ayarlayabilir.

İş parçacığının önceliği iş parçacığının durumunu etkilemez; İş parçacığının durumu, işletim sisteminin zamanlaması için önce olmalıdır Running .

Ayrıca bkz.

• Thread
• İş parçacıklarını zamanlama