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:

Megjegyzés: Nem szükséges, hogy a többszálakban alkalmazott módszerek statikusak legyenek, mint a fenti két példában, mind az eljárás, azaz az 1. módszer és a 2. módszer statikus. Ezek a módszerek nem statikusak lehetnek, és ebben az esetben először létre kell hoznunk egy metódust tartalmazó osztály objektumát, majd az objektum segítségével hozzáférhetünk a módszerekhez.

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

  1. 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.
  2. 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.
  3. A szálak minimalizálják a rendszer erőforrásainak felhasználását, mivel ugyanazzal a címtérrel rendelkeznek.
  4. 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 -

  1. Objektumok a C # -ben
  2. Romboló C # -ben
  3. Romboló C # -ben
  4. Öröklés a C # -ben
  5. Romboló a PHP-ben Példák

Kategória:

Szoftverfejlesztés