Miért lassabb a .net/c# feladat, mint a Thread?

Kis szemét · Közzétéve 2017. 05. 03. 16:40:28

A .NET 4 tartalmaz egy új névteret, a System.Threading.Tasks-t, amely olyan osztályokat tartalmaz, amelyek kivonják a szálas funkciókat. Használd a ThreadPool-t a háttérben. A feladat egy egység munkáját jelenti, amelyet el kell fejezni. Ennek az egységnek a munkája külön szálban futtatható, vagy egy feladat szinkronban indítható, ami a fő hangolási szálra várni kell. A feladatok használata nemcsak egy absztrakciós réteget ad, hanem sok irányítást is ad az alapul szolgáló szálak felett.
A feladatok nagy rugalmasságot kínálnak a munka ütemezésében. Például definiálhatsz egy folyamatos feladatot – hogy milyen munkát kell végezni egy feladat befejezése után. Ez lehet a különbség a sikeres vagy a sikertelen feladat között. Emellett a feladatok hierarchiában is elrendezhetők. Például egy szülői feladat létrehozhat egy új gyermekfeladatot. Ez függőséget hoz létre, így ha lemondod a szülő feladatot, a gyermekfeladat is törlésre kerül.

Manapság népszerű a feladatvégrehajtási módszerek, amelyek nagy teljesítményűek, és nem tudom, hol van a feladatteljesítmény.

Én magam teszteltem a Task-t és a Thread-et, és úgy érzem, a Task nagyon lassú, ami jelentősen befolyásolja a teljesítményt, a tesztkód pedig a következő:

A bejelentkezés látható.

A módszert 1000-szer körözzük, majd a módszert 100 milliszekundumig blokkoljuk, és a teszteredmény a következő:

Eredmény:
A szál végrehajtása 188 milliszekundumot vesz igénybe
A feladat végrehajtása 14 671 milliszekundumot vesz igénybe

A két sebesség közötti különbség 78-szoros!!

A feladat nagyon lassú, nem tudom, miért történik ez, van valami baj a tesztkódommal, vagy mi? Remélem, el tudod magyarázni, miért történik ez...

Kis szemét · Közzétéve 2020. 10. 13. 10:47:17

tongli1996218 Közzétéve: 2020-10-13 09:34
Ahhoz, hogy ugyanazt a kódot biztosítsam, mint a Thread, a következő kód a következő művelet, és a fenti pszeudokód
Ui.: Csak hívd a várakozást a Feladat.Késleltetésre anélkül, hogy hozzáadnánk ...

Igen, köszönöm

Feladat végrehajtási ideje: 117.0357

A bejelentkezés látható.

A kódot az alábbiak szerint módosíthatod:

A bejelentkezés látható.

A Task.Run helyettesíti a Task.Factory.StartNew szervert, mert automatikusan bontja ki a belső feladatokat.
Task.WaitAll külső feladatra vár a belső helyett. A Task.Run használata nem tartalmaz beágyazott feladatokat.

Az msdn dokumentációt nézve látható, hogy a Task.Delay Method metódus egy adott milliszekundum után befejező feladatot hoz létre. (Valójában egy új szál jön létre, és hozzáadják az await-t, hogy megvárjam a feladat végrehajtását, nem tudom, jól értem-e)

A hiperlink bejelentkezés látható.

Emellett különbség van a feladat és a semmi között

A feladat egy aszinkron metódust ad vissza, amely várakozásra alkalmas
A void return aszinkron módszer nem várhat, aszinkron módon működik, nem tudhatod, mikor végezt, nem lehet figyelni az aszinkron művelet állapotát.

Utalás:

A hiperlink bejelentkezés látható.
A hiperlink bejelentkezés látható.

Összefoglalva: van probléma a kóddal, nem szabad a Thread.Sleep-et a Feladat metódban használni

sususu996 · Közzétéve 2020. 07. 21. 13:09:29

Nálam is ugyanez volt a problémám, amikor multithreadinget használtam AES titkosításhoz, a Task sokkal lassabb, mint a Thread!!
Megtalálta a főbérlő az okot?

tongli1996218 · Közzétéve 2020. 10. 12. 19:24:48

Ezt a bejegyzést utoljára tongli1996218 szerkesztette: 2020-10-12 19:43

A tulajdonos kódjának tesztelése után, amikor a programot többször is elindítják és futtatják, a feladat ideje tovább csökken, és a számítógépemen kevesebbre csökken, mint a Thread, és a Thread ebben az időben stabil lesz.

Később kiderült, hogy a Thread.Sleep(100) módszer negatív hatással volt a Task-ra, de a Thread-re nem, és a Thread.Sleep(100) helyettesíthető más időigényes programellenőrzéssel, például numerikus önösszeadással vagy várakozással Task.Delay(100) megoldással.

Ui.Ui.: A Thread.Sleep a hívás után megszünteti a jelenlegi szál szeletelési idejét, például a Thread.Sleep(0) megszünteti a jelenlegi szál szeletelési idejét, és átviszi más szálaknak, hogy futjanak. A feladaton belül egy szál pool található, amely optimalizálhatja a szálak kontextusváltását és csökkenti a CPU-veszteség idejét (különösen többmagos CPU optimalizálásnál), míg a Thread.Sleep(100) megzavarja az eredeti szálkészlet kapcsoló logikáját, ami jelentős CPU-időveszteséget okoz

Ha a Thread.Sleep(100) lecseréled a wait Task.Delay(100) opcióra, akkor azt tapasztalhatod, hogy a feladat időigénye csak 100 milliszekundumust halad, ahogy az alábbiakban látható:
private void TaskTest()
{
      Thread.Sleep (100);
      ... Hajtsd végre a cselekvést
}
Felváltva
private async void TaskTest()
{
   várják a feladatot. Késleltetés(100);
   ... A végrehajtás több mint 100 milliszekundumust vesz igénybe a feladathoz, ami megegyezik az eredeti Thread.Sleep(100) Thread-nél
}

Kis szemét · Közzétéve 2020. 10. 12. 22:53:05

tongli1996218 Közzétéve: 2020-10-12 19:24
A tulajdonos kódjának tesztelése után, amikor a program elindul, a feladat ideje többszöri futtatás után is csökkenni fog, és a számítógépemen kevesebbre csökken, mint a Thread...

Megpróbáltam így kódra változtatni:

A bejelentkezés látható.

Task.Delay(100000);

Feladat végrehajtási ideje:14.1306 ms, az összidő valóban nagyon rövid, azonban azt tapasztaltam, hogy a Feladat által hívott módszer nem fejezte be a végrehajtást.

tongli1996218 · Közzétéve 2020. 10. 13. 9:34:33

Ezt a bejegyzést utoljára tongli1996218 szerkesztette 2020-10-13-án 09:40-kor

Megjelent: 2020-10-12 22:53
Megpróbáltam így kódra változtatni:
Task.Delay(100000);

Ahhoz, hogy ugyanazt a kódot biztosítsam, mint a Thread, a következő kód a következő művelet, és a fenti pszeudokód
Ui.: Csak hívd meg a Task.Delay várjat, majd adj hozzá kódot a feladat által megnyitott szál azonnal visszakerül, hogy biztosítsd a számítási kötött szimulációt, amit használhatsz (int a = 0; a< 1000000; ++a){}; Ehelyett ilyen módszerek

private async static void TaskTest()
      {
         várják a feladatot. Késleltetés(100000);
         Interlocked.Increment (ref futás); zárol, de a felső rész kisebb
         if(run == j)
         {
            stopperórá. Stop(); Megállítsd a megfigyelést
            TimeSpan időspan = stopper. Letelt;  Megkapja az aktuális példány által mért teljes időt
            Console.WriteLine("Feladat végrehajtási idő:" + időspan. TotalMilliseconds); Összesen milliszekundum
            }
      Az időigény is nagyon rövid

[Forrás] Miért lassabb a .net/c# feladat, mint a Thread?

Megtekintett szakaszok