Megosztás a következőn keresztül:

Ütemezési szálak

Minden szálhoz tartozik egy szálprioritás. A közös nyelvi futtatókörnyezetben létrehozott szálak kezdetben a következő prioritást kapják ThreadPriority.Normal: . A futtatókörnyezeten kívül létrehozott szálak megőrzik a felügyelt környezetbe való belépés előtt kapott prioritást. A tulajdonsággal bármely szál prioritását lekérheti vagy beállíthatja Thread.Priority .

A szálak a prioritásuk alapján vannak ütemezve a végrehajtásra. Annak ellenére, hogy a szálak a futtatókörnyezeten belül futnak, az operációs rendszer minden szálhoz processzoridőszeleteket rendel. A szálak végrehajtásának sorrendjét meghatározó ütemezési algoritmus részletei az egyes operációs rendszerektől függően változnak. Egyes operációs rendszerekben a legmagasabb prioritású szál (a végrehajtható szálak közül) mindig az első futtatásra van ütemezve. Ha több azonos prioritású szál is elérhető, az ütemező az adott prioritású szálakon halad végig, így minden szálhoz rögzített időszeletet ad, amelyben végre kell hajtani. Mindaddig, amíg egy magasabb prioritású szál futtatható, az alacsonyabb prioritású szálak nem lesznek végrehajtva. Ha nincs több futtatható szál egy adott prioritásnál, az ütemező a következő alacsonyabb prioritásra lép, és a szálakat az adott prioritásra ütemezi a végrehajtáshoz. Ha egy magasabb prioritású szál futtathatóvá válik, az alacsonyabb prioritású szál elő van véve, és a magasabb prioritású szál ismét végrehajtható. Mindezek mellett az operációs rendszer dinamikusan is módosíthatja a szálprioritásokat, mivel az alkalmazás felhasználói felülete az előtérben és a háttérben mozog. Más operációs rendszerek dönthetnek úgy, hogy más ütemezési algoritmust használnak.

Példa

Íme egy példa 9 szál végrehajtására az enumerálás mind az Thread.Priority 5 prioritási szintjén, ahol az utolsó 5 a legmagasabb prioritási szinten van. Emellett az előző cikk visszahívási támogatását is támogatjuk, amely ebben a kontextusban azt mutatja, hogy a szál inicializálásának és rangsorolásának sorrendje nem mindig jelenik meg a következő kódban, és a folyamatvégrehajtások sorrendje sem. Ez azt jelenti, hogy itt látható a kódvégrehajtás párhuzamos jellege, valamint a hozzárendelt processzoridőszeletek bemutatása az operációs rendszer által minden szálhoz. Ez kiemeli annak a környezetnek a hatását és szabályozását, amelyben a szálak futnak. Ezzel azt látjuk, hogy a legmagasabb prioritású szálak valóban elsőbbséget élveznek a végrehajtás során.

Az alábbi kód tetszőleges eredményeket hoz létre az egyes végrehajtások során. A kód többszöri futtatása és a kimenetek elemzése után azonban megfigyelhetők a futtatandó prioritások gyakori sorrendi mintái.

namespace snippets;

public class SchedulingThreads
{
    public void RunMultipleThreadsOnDifferentPriorities()
    {
        var threadsList = new List<Thread>(9);

        // Initialize 9 threads. 5 with Highest priority, and the first 4 from Lowest to Normal range.
        for (int i = 0; i < 9; i++)
        {
            var thread = new Thread(() => { new ThreadWithCallback(Callback).Process(); });

            if (i > 3)
                thread.Priority = ThreadPriority.Highest;
            else
                thread.Priority = (ThreadPriority)i;

            threadsList.Add(thread);
        }

        threadsList.ForEach(thread => thread.Start());
    }

    public void Callback(ThreadPriority threadPriority)
    {
        Console.WriteLine($"Callback in {threadPriority} priority. \t\t ThreadId: {Thread.CurrentThread.ManagedThreadId}.");
    }

    public class ThreadWithCallback
    {
        public ThreadWithCallback(Action<ThreadPriority> callback)
        {
            this.callback = callback;
        }

        public Action<ThreadPriority> callback;

        public void Process()
        {
            Console.WriteLine($"Entered process in {Thread.CurrentThread.Priority} priority.  \t\t ThreadId: {Thread.CurrentThread.ManagedThreadId}.");
            Thread.Sleep(1000);
            Console.WriteLine($"Finished process in {Thread.CurrentThread.Priority} priority. \t\t ThreadId: {Thread.CurrentThread.ManagedThreadId}.");

            if (callback != null)
            {
                callback(Thread.CurrentThread.Priority);
            }
        }
    }

    // The example displays the output like the following:
    //      Entered process in Highest priority.             ThreadId: 9.
    //      Entered process in Highest priority.             ThreadId: 12.
    //      Entered process in Normal priority.              ThreadId: 6.
    //      Entered process in BelowNormal priority.         ThreadId: 5.
    //      Entered process in Lowest priority.              ThreadId: 4.
    //      Entered process in AboveNormal priority.         ThreadId: 7.
    //      Entered process in Highest priority.             ThreadId: 11.
    //      Entered process in Highest priority.             ThreadId: 10.
    //      Entered process in Highest priority.             ThreadId: 8.
    //      Finished process in Highest priority.            ThreadId: 9.
    //      Finished process in Highest priority.            ThreadId: 12.
    //      Finished process in Highest priority.            ThreadId: 8.
    //      Finished process in Highest priority.            ThreadId: 10.
    //      Callback in Highest priority.                    ThreadId: 10.
    //      Finished process in AboveNormal priority.        ThreadId: 7.
    //      Callback in AboveNormal priority.                ThreadId: 7.
    //      Finished process in Lowest priority.             ThreadId: 4.
    //      Callback in Lowest priority.                     ThreadId: 4.
    //      Finished process in Normal priority.             ThreadId: 6.
    //      Callback in Highest priority.                    ThreadId: 9.
    //      Callback in Highest priority.                    ThreadId: 8.
    //      Callback in Highest priority.                    ThreadId: 12.
    //      Finished process in Highest priority.            ThreadId: 11.
    //      Callback in Highest priority.                    ThreadId: 11.
    //      Callback in Normal priority.                     ThreadId: 6.
    //      Finished process in BelowNormal priority.        ThreadId: 5.
    //      Callback in BelowNormal priority.                ThreadId: 5.
}

Lásd még