C# .NET menyediakan alat yang berkuasa untuk pengaturcaraan serentak, selari dan multithreaded. 1 1) Gunakan kelas benang untuk membuat dan menguruskan benang, 2) kelas tugas menyediakan abstraksi yang lebih maju, memanfaatkan kolam benang untuk meningkatkan penggunaan sumber, 3) melaksanakan pengkomputeran selari melalui paralel.foreach, 4) async/menunggu dan tugas.

Pengenalan

Dalam pembangunan perisian moden, bagaimana untuk menggunakan sumber komputer secara cekap telah menjadi isu utama. Terutama apabila memproses sejumlah besar data atau memerlukan pelbagai tugas yang dilakukan secara serentak, C# .NET menyediakan satu set alat yang kuat untuk melaksanakan pengaturcaraan serentak, selari dan multithreaded. Hari ini, kami akan menggali jauh ke dalam konsep -konsep ini untuk membantu anda memahami bagaimana untuk mencapai multitasking yang cekap di C#. Melalui artikel ini, anda akan belajar cara menggunakan ciri C# untuk meningkatkan prestasi dan respons program anda.

Semak pengetahuan asas

Sebelum kita memulakan, mari kita cepat semak asas -asas. Concurrency merujuk kepada pelbagai tugas yang dilaksanakan dalam tempoh masa yang sama, sementara paralelisme merujuk kepada pelbagai tugas yang dilaksanakan pada masa yang sama. Multithreading adalah cara untuk melaksanakan kesesuaian dan paralelisme. Ia membolehkan program untuk melaksanakan pelbagai benang pada masa yang sama.

C# menyediakan perpustakaan dan rangka kerja yang kaya untuk menyokong konsep -konsep ini, seperti System.Threading and System.Threading.Tasks Namespaces. Memahami pengetahuan asas ini adalah penting untuk pembelajaran berikutnya.

Konsep teras atau analisis fungsi

Definisi dan fungsi kesesuaian, paralelisme dan multithreading

Konvensyen dan paralelisme adalah konsep penting dalam pengaturcaraan moden. Concurrency membolehkan program untuk memproses pelbagai tugas dalam tempoh masa yang sama, sementara selari memerlukan tugas -tugas ini dilaksanakan pada masa yang sama. Multithreading adalah cara biasa untuk melaksanakan konsep -konsep ini, yang membolehkan program untuk melaksanakan pelbagai benang pada masa yang sama, dengan itu meningkatkan respons dan kecekapan program.

Sebagai contoh, katakan anda sedang membangunkan pelayan web yang perlu memproses permintaan pelanggan berganda pada masa yang sama. Dengan multithreading, anda boleh membuat thread bebas untuk setiap permintaan klien, dengan itu meningkatkan kelajuan tindak balas dan kuasa pemprosesan pelayan.

 menggunakan sistem;
menggunakan System.Threading;

program kelas
{
    statik kekosongan utama (string [] args)
    {
        // Buat dua benang Thread Thread1 = thread baru (threadProc);
        Thread thread2 = thread baru (threadProc);

        // Start Thread Thread1.Start ();
        Thread2.start ();

        // tunggu benang menyelesaikan thread1.join ();
        thread2.join ();
    }

    Static Void ThreadProc ()
    {
        untuk (int i = 0; i <5; i)
        {
            Console.writeline ($ "thread {thread.currentthread.managedthreadid}: {i}");
            Thread.sleep (1000); // kerja simulasi}
    }
}

Contoh mudah ini menunjukkan cara membuat dan memulakan dua benang, masing -masing melakukan tugas yang sama, tetapi mereka dilaksanakan secara serentak.

Bagaimana ia berfungsi

Prinsip kerja multithreading melibatkan penjadualan thread dan pengurusan sistem operasi. Setiap benang mempunyai konteks pelaksanaannya sendiri, termasuk kaunter program, daftar, dan susunan. Sistem operasi bertanggungjawab untuk menukar antara benang yang berbeza untuk mencapai pelaksanaan serentak.

Dalam C#, kelas Thread menyediakan fungsi asas untuk membuat dan mengurus benang, sementara kelas Task menyediakan abstraksi yang lebih maju, membolehkan anda menulis kod serentak dengan lebih mudah. Kelas Task menggunakan kolam benang secara dalaman untuk menguruskan benang, dengan itu meningkatkan penggunaan dan prestasi sumber.

Pemahaman yang mendalam tentang bagaimana kerja multithreading dapat membantu anda merancang dan mengoptimumkan program serentak. Sebagai contoh, memahami algoritma penjadualan thread boleh membantu anda mengelakkan kebuntuan dan keadaan perlumbaan, sambil memahami model memori dapat membantu anda mengendalikan data yang dikongsi dengan betul.

Contoh penggunaan

Penggunaan asas

Mari kita lihat contoh mudah yang menunjukkan cara melaksanakan pengkomputeran selari menggunakan Task . Dengan mengandaikan kita perlu mengira jumlah kuadrat semua elemen dalam array, kita boleh menggunakan pengiraan selari untuk meningkatkan prestasi.

 menggunakan sistem;
menggunakan System.Linq;
menggunakan System.Threading.tasks;

program kelas
{
    statik kekosongan utama (string [] args)
    {
        int [] nombor = enumerable.range (1, 1000000) .toArray ();
        Jumlah panjang = 0;

        // Gunakan pengiraan selari selari.foreach (nombor, num =>
        {
            jumlah = (panjang) math.pow (num, 2);
        });

        Console.WriteLine ($ "Jumlah Squares: {Sum}");
    }
}

Dalam contoh ini, kami menggunakan Parallel.ForEach untuk mengira jumlah kuadrat setiap elemen dalam array secara selari. Parallel.ForEach akan secara automatik membahagikan tugas ke dalam pelbagai bahagian dan melaksanakan pada pelbagai benang, dengan itu meningkatkan kelajuan pengiraan.

Penggunaan lanjutan

Dalam senario yang lebih kompleks, kita mungkin perlu mengawal keseragaman dan paralelisme lebih berbutir. Sebagai contoh, katakan kita perlu mendapatkan data dari pelbagai sumber data dan memprosesnya semasa mendapatkan data. Kita boleh menggunakan Task dan async/await untuk melaksanakan fungsi ini.

 menggunakan sistem;
menggunakan System.Threading.tasks;

program kelas
{
    Tugas Async Static Main (String [] args)
    {
        // simulasi untuk mendapatkan data dari pelbagai sumber data var tugas1 = getDataAsync ("source1");
        var tugas2 = getDataAsync ("Source2");

        // tunggu semua tugas untuk menyelesaikan tugas menanti.whenall (Task1, Task2);

        // Proses data var result1 = menunggu tugas1;
        var result2 = menunggu tugas2;

        Console.WriteLine ($ "Data dari Source1: {result1}");
        Console.WriteLine ($ "Data dari Source2: {result2}");
    }

    Tugas Async Statik <string> getDataAsync (Sumber String)
    {
        // mensimulasikan kelewatan dalam mendapatkan tugas menunggu data.Delay (2000);
        kembali $ "data dari {source}";
    }
}

Dalam contoh ini, kami menggunakan async/await dan Task.WhenAll Apabila mendapatkan data selari dan memprosesnya selepas pengambilalihan data selesai. Pendekatan ini dapat meningkatkan respons dan kecekapan program dengan ketara.

Kesilapan biasa dan tip debugging

Kesalahan biasa dalam pengaturcaraan multithread termasuk kebuntuan, keadaan kaum, dan kebocoran benang. Mari kita lihat beberapa kesilapan biasa dan tip debug.

• Deadlock : Deadlock merujuk kepada dua atau lebih benang yang menunggu satu sama lain untuk melepaskan sumber, menyebabkan program itu tidak dapat meneruskan pelaksanaan. Salah satu cara untuk mengelakkan kebuntuan adalah memastikan benang memperoleh sumber dalam urutan yang sama.

• Keadaan persaingan : Keadaan persaingan merujuk kepada pelbagai benang mengakses sumber yang dikongsi pada masa yang sama, mengakibatkan hasil yang tidak dapat diramalkan. Keadaan kaum boleh dielakkan menggunakan kunci (seperti pernyataan lock ) atau mekanisme penyegerakan yang lebih maju (seperti SemaphoreSlim ).

• Kebocoran benang : Kebocoran benang adalah apabila benang dicipta tetapi mereka tidak ditamatkan dengan betul, mengakibatkan pembaziran sumber. Untuk memastikan bahawa benang ditamatkan dengan betul apabila tidak diperlukan, anda boleh menggunakan kelas Task untuk menguruskan kitaran hayat thread.

Apabila menyahpepijat program multithreaded, anda boleh menggunakan alat visualisasi bersamaan Visual Studio untuk menganalisis pelaksanaan thread dan mengesan kebuntuan dan keadaan perlumbaan.

Pengoptimuman prestasi dan amalan terbaik

Dalam aplikasi praktikal, mengoptimumkan prestasi program berbilang threaded adalah isu utama. Mari kita lihat beberapa petua pengoptimuman dan amalan terbaik.

• Menggunakan kolam benang : Kolam benang boleh mengurangkan overhead penciptaan benang dan kemusnahan dan meningkatkan penggunaan sumber. ThreadPool dan kelas Task di C# Gunakan kolam thread di dalamnya.

• Elakkan paralelisme yang berlebihan : Terlalu banyak tugas selari boleh menyebabkan overhead konteks beralih melebihi manfaat paralelisme. Gunakan kelas ParallelOptions untuk mengawal had atas paralelisme.

• Menggunakan pengaturcaraan asynchronous : Pengaturcaraan asynchronous dapat meningkatkan responsif program, terutama dalam operasi I/O-intensif. Menggunakan async/await dapat memudahkan kerumitan pengaturcaraan tak segerak.

• Kod Pembacaan dan Penyelenggaraan : Pastikan pembacaan dan penyelenggaraan kod semasa menulis kod multithreaded. Gunakan penamaan dan anotasi yang jelas untuk mengelakkan logik yang terlalu kompleks.

Dengan teknik pengoptimuman dan amalan terbaik ini, anda boleh memanfaatkan keseragaman dan paralelisme C# untuk menulis program multi-threaded yang cekap dan dikekalkan.

Dalam pengaturcaraan multithread, pemahaman dan penggunaan konsep -konsep ini bukan sahaja dapat meningkatkan prestasi program anda, tetapi juga meningkatkan kemahiran pengaturcaraan anda. Saya harap artikel ini dapat memberi anda pandangan yang berharga dan panduan praktikal untuk membantu anda dengan mudah dalam pembangunan C# .net.

Atas ialah kandungan terperinci Advanced C# .NET: Concurrency, Paralelism, dan Multithreading dijelaskan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!