Mitmekeeruline C # - -is Mitmekeermelise loomine ja meetodid C # -s

• Sissejuhatus mitmekeelsusesse C # -s

Sissejuhatus mitmekeelsusesse C # -s

C # mitmekordse keerukuse mõistmiseks mõelgem kõigepealt, mis on niit?

• Niit on kerge protsess.
• See on programmi täitmisrada.
• See on operatsioonisüsteemi väikseim töötlemisüksus.
• Seega võib protsessil olla mitu lõime.

Niisiis, mitmekiuline lõng on protsess, mis sisaldab mitut lõime, kus iga lõim täidab erinevat tegevust. See säästab aega, kuna mitu lõime täidab korraga mitu ülesannet. See suurendab protsessori kasutamist ja suurendab rakenduse tõhusust. See töötab ajajaotuse kontseptsiooni alusel.

Süntaks selgitusega

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();

Lõime loomiseks peame looma lõime klassi objekti. Thread klassi konstruktor viitab ThreadStartile. ThreadStart on delegaat, kes tähistab meetodit, mis tuleb käivitada, kui lõim käivitab.

Niit alustab täitmist, kui nimetatakse Start () meetodit.

Lõime saab luua ilma ThreadStart-i delegaati kasutamata, nagu on näidatud allolevas süntaksis:

Thread thread_name = new Thread(method_to_be_executed);
thread_name.Start();

Mitme lõime loomine C # -s

Lõimede loomiseks peame süsteemi importima. Nimeseruumi lõimimine. Lõime saame luua ja lähtestada, kasutades lõime klassi.

Näide, kasutades niidiklassi

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();
)
)

Väljund:

Näide, kasutades ThreadStart delegaati

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();
)
)

Väljund:

Märkus. Mitmekordses keermestamises kasutatavad meetodid ei pea olema staatilised, nagu kahe eelneva näite puhul, mõlemad meetodid, st meetod1 ja meetod2, on staatilised. Need meetodid võivad olla mittestaatilised ja sel juhul peame kõigepealt looma klassi kuuluva objekti, mis sisaldab meetodeid, ja seejärel pääseme objektile juurde meetoditega.

C #-s sisaldab programm alati ühte lõime, st peamist lõime. Muude lõimede loomisel saab sellest mitmekäeline programm ja C # mitmekeelses lõimes on kahte tüüpi lõime:

• Esiplaanilõng : see lõim jätkab täitmist, kuni see lõpetab oma töö, isegi kui põhilõng lõpeb.
• Taustniit : kui põhiteema lõpeb, peatub ka taustalõime käivitamine ja lõpetatakse põhikeermega.

Meetodid näidetega

Vaatame mõnda lõimeklassi kõige sagedamini kasutatavat meetodit koos näidetega.

• Sleep (): kasutatakse praeguse lõime täitmise peatamiseks kindlaksmääratud aja jooksul, nii et teised lõimed hakkaksid täitmist.

Näide:

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();
)
)

Väljund:

Väljund näitab, et mõlemad lõimed on teostatud paralleelselt.

• Katkesta (): kasutatakse lõime katkestamiseks või võime öelda, et seda kasutatakse lõime lõplikuks peatamiseks.

Näide

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());
)
)
)

Väljund:

• Liitu (): kasutatakse selleks, et kõik kõneldavad lõimed ootaksid, kuni praegune lõim lõpetab selle täitmise ja lõpeb.

Näide:

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();
)
)

Väljund:

Mitmekeelsuse eelised C # -s

1. Aitab reageeriva kasutajaliidese säilitamisel: Mõnikord on meie rakenduses aeganõudev meetod. Sel juhul, kui muudame oma rakenduse mitme keermega, vastutab selle meetodi täitmise eest teine ​​teema, kui põhiline teema saab keskenduda rakenduse reageerimisele. Seega ei külmuta see meie rakendust, andes kasutajale õigeaegselt õige vastuse.
2. Suurendab rakenduse toimivust: kui meil on nii palju lõime, kui protsessori südamikke on, siis töötab iga lõim iseseisvalt, suurendades arvutuste arvu sekundis.
3. Lõimed minimeerivad süsteemiressursside kasutamist, kuna neil on sama aadressiruum.
4. See muudab koodi korraga kiiremaks ja lihtsamaks.

Järeldus - mitmekordne lõng C-s

Keermeklass pakub palju olulisi omadusi nagu Priority, Name, IsAlive, taust, mida saame kasutada meie mitmekeelses rakenduses. Lõimede sünkroonimine on tehnika, mille abil lõim saab kindla aja jooksul ressursile juurde pääseda ilma teiste lõimede katkestamiseta, kuni see on oma ülesande lõpule viinud.

Soovitatavad artiklid

See on olnud teejuht C # mitmekordse lõime jaoks. Siin käsitleme ka nende sissejuhatust, süntaksit, loomist ja näiteid mitmekeelsest lõimest c #-s. Võite lisateabe saamiseks vaadata ka järgmisi artikleid -

1. C-tüüpi objektid
2. C-tüüpi hävitaja
3. C-tüüpi hävitaja
4. Pärand C # -s
5. Hävitaja PHP-s | Näited