Bevezetés a C #
A c # többszálú megértéséhez először megértsük, mi az a szál?
- A szál egy könnyű eljárás.
- Ez egy program végrehajtási útja.
- Ez a legkisebb feldolgozási egység az operációs rendszerben.
- Így egy folyamatnak több szála lehet.
Tehát a többszálú eljárás egy olyan folyamat, amely több szálat tartalmaz, ahol az egyes szálak eltérő tevékenységet végeznek. Időt takarít meg, mivel több feladatot hajtanak végre egyszerre különböző szálak. Növeli a CPU kihasználtságát és növeli az alkalmazás hatékonyságát. Ez az időmegosztási koncepción működik.
Szintaxis magyarázattal
Thread first_thread_name = new Thread(new ThreadStart(method_to_be_executed1));
Thread second_thread_name = new Thread(new ThreadStart(method_to_be_executed2));
first_thread_name.Start();
second_thread_name.Start();
Szálat létrehozásához létre kell hoznunk egy szál osztály objektumát. A szál osztály-kivitelező hivatkozik a ThreadStart-ra. A ThreadStart egy megbízott, amely olyan módszert reprezentál, amelyet végre kell hajtani, amikor a szálat végrehajtják.
A szál a végrehajtás megkezdésekor a Start () metódust hívják.
Létrehozhatunk egy szálat a ThreadStart delegált nélkül, az alábbi szintaxis szerint:
Thread thread_name = new Thread(method_to_be_executed);
thread_name.Start();
Több szál létrehozása a C # -ben
Szálak létrehozásához be kell importálnunk a rendszert. A szálak létrehozása és inicializálása a Szálak osztály használatával lehetséges.
Példa a szál osztály használatával
using System;
using System.Threading;
public class MultiThreadingDemo
(
public static void Method1()
(
for (int i = 0; i <= 5; i++)
(
Console.WriteLine("Method1 : (0)", i);
)
)
public static void Method2()
(
for (int i = 0; i <= 5; i++)
(
Console.WriteLine("Method2 : (0)", i);
)
)
public static void Main()
(
// Creating and initializing threads
Thread thread1 = new Thread(Method1);
Thread thread2 = new Thread(Method2);
//beginning thread execution
thread1.Start();
thread2.Start();
)
)
Kimenet:
Példa a ThreadStart megbízott segítségével
using System;
using System.Threading;
public class MultiThreading
(
public static void Method1()
(
for (int i = 1; i <= 5; i++)
(
Console.WriteLine("Method1 : (0)", i);
)
)
public static void Method2()
(
for (int i = 1; i <= 5; i++)
(
Console.WriteLine("Method2 : (0)", i);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Thread thread1 = new Thread(new ThreadStart(MultiThreading.Method1 ) );
Thread thread2 = new Thread(new ThreadStart(MultiThreading.Method2 ) );
thread1.Start();
thread2.Start();
)
)
Kimenet:
A C # esetében a program mindig egy szálat tartalmaz, azaz a Főszálat. Más szálak létrehozásakor többszálú programmá válik, és a C # többszálú szálaknak kétféle típusa van:
- Előtér szál : Ez a szál addig fut, amíg befejezi a munkáját, még akkor sem, ha a fő szál leáll.
- Háttér szál : Amikor a fő szál lezárul, a háttér szál szintén leállítja a végrehajtást és a fő szállal befejeződik.
Módszerek példákkal
Nézzük meg néhány, a szál osztály általánosan használt módszert példákkal.
- Alvás (): Az aktuális szál végrehajtásának szüneteltetésére szolgál egy meghatározott ideig, hogy más szálak kezdjék meg a végrehajtást.
Példa:
using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 1; i <= 10; i++)
(
Console.WriteLine(i);
//suspending execution of current thread for 100 milliseconds
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
thread1.Start();
thread2.Start();
)
)
Kimenet:
A kimenet azt mutatja, hogy mindkét szál párhuzamosan fut.
- Megszakítás (): A szál lezárására szolgál, vagy mondhatjuk, hogy a szál végrehajtásának végleges leállítására használják.
Példa
using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 0; i < 10; i++)
(
Console.WriteLine(i);
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
Console.WriteLine("Threads start execution");
thread1.Start();
thread2.Start();
try
(
//terminating execution of thread using Abort()
thread1.Abort();
thread2.Abort();
Console.WriteLine("Threads execution terminated");
)
catch (ThreadAbortException threadAbortException)
(
Console.WriteLine(threadAbortException.ToString());
)
)
)
Kimenet:
- Csatlakozás (): Minden hívó szálat arra késztetett, hogy várja meg, amíg az aktuális szál befejezi a futtatást és leáll.
Példa:
using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 0; i < 5; i++)
(
Thread thread = Thread.CurrentThread;
Console.WriteLine(thread.Name +" : "+i);
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
Thread thread3 = new Thread(new ThreadStart(multithreading.Display));
//Assigning names to threads using Name property
thread1.Name = "Thread1";
thread2.Name = "Thread2";
thread3.Name = "Thread3";
thread1.Start();
//Making Thread2 and Thread3 wait until Thread1 completes execution
thread1.Join();
thread2.Start();
thread3.Start();
)
)
Kimenet:
A többszálak előnyei a C # -ben
- Segít a rugalmas felhasználói felület fenntartásában: Alkalmazásunkban néha időigényes módszer van. Ebben az esetben, ha az alkalmazást többszálúvá tesszük, akkor egy másik szál vállalja a felelősséget az adott módszer végrehajtásáért, míg a Fő szál az alkalmazás válaszkészségére összpontosíthat. Így nem fagyasztja be alkalmazásunkat azáltal, hogy időben megfelelő választ ad a felhasználónak.
- Növeli az alkalmazás teljesítményét: Ha annyi szál van, mint amennyi processzormag van, akkor minden szál egymástól függetlenül fut, növelve a másodpercenkénti számítások számát.
- A szálak minimalizálják a rendszer erőforrásainak felhasználását, mivel ugyanazzal a címtérrel rendelkeznek.
- Ez a kód egyszerre gyorsabbá és egyszerűbbé teszi.
Következtetés - többszálú C #
A szálak osztálya számos fontos tulajdonságot nyújt, mint például a Priority, Name, IsAlive, háttér, amelyeket felhasználhatunk többszálú alkalmazásunkban. A szálszinkronizálás olyan technika, amellyel a szál egy adott időtartamra hozzáférhet egy erőforráshoz más szálak megszakítása nélkül, amíg a feladatát nem fejezi be.
Ajánlott cikkek
Ez egy útmutató a C # többszálatához. Itt tárgyaljuk a bevezetésüket, a szintaxist, a létrehozást és a c # többszálak példáit. Lehet, hogy megnézi a következő cikkeket is, ha többet szeretne megtudni -
- Objektumok a C # -ben
- Romboló C # -ben
- Romboló C # -ben
- Öröklés a C # -ben
- Romboló a PHP-ben Példák