Cara menggunakan model pengaturcaraan tak segerak dan pengaturcaraan serentak untuk mengendalikan pengagihan tugas dan penyelesaian dalam C#

Cara menggunakan model pengaturcaraan tak segerak dan pengaturcaraan serentak untuk mengendalikan pengagihan tugas dan penyelesaian dalam C#

Pengenalan:
Dalam perisian moden Semasa pembangunan, kita sering menghadapi situasi memproses sejumlah besar tugas, dan tugas-tugas ini mungkin bebas dan tidak mengganggu antara satu sama lain. Untuk meningkatkan prestasi dan kecekapan program, kami berharap dapat memproses tugasan ini secara serentak dan mendapatkan hasil yang sepadan apabila setiap tugasan selesai. Sebagai bahasa pengaturcaraan berorientasikan objek, C# menyediakan model pengaturcaraan tak segerak dan penyelesaian pengaturcaraan serentak Dengan menggunakan ciri ini dengan sewajarnya, pengagihan tugas dan penyelesaian masalah boleh dikendalikan dengan berkesan.

1. Model pengaturcaraan tak segerak
Model pengaturcaraan tak segerak bermaksud bahawa apabila melaksanakan tugas tertentu, utas utama tidak akan disekat, tetapi tugas itu akan diwakilkan secara tidak segerak kepada utas atau kumpulan benang lain . pemprosesan, utas utama boleh terus melakukan operasi lain. Dalam C#, model pengaturcaraan tak segerak boleh dilaksanakan dengan menggunakan kata kunci tak segerak dan menunggu. Berikut ialah contoh menggunakan model pengaturcaraan tak segerak:

static async Task<int> DoSomeWorkAsync()
{
    // 模拟一个耗时操作
    await Task.Delay(1000);
    return 42;
}

static async void Main(string[] args)
{
    Console.WriteLine("开始执行任务");
    int result = await DoSomeWorkAsync();
    Console.WriteLine("任务结果：" + result);
    Console.WriteLine("任务执行完毕");

    // 等待用户输入，防止控制台窗口关闭
    Console.ReadLine();
}

Dalam kod di atas, kaedah DoSomeWorkAsync() ialah kaedah tak segerak dan kata kunci await memberitahu pengkompil untuk tidak melaksanakan Tugasan. Kelewatan () kaedah akan menyekat benang utama. Kaedah Main() juga ditandakan sebagai kaedah tak segerak dan menggunakan kata kunci await untuk menunggu keputusan kaedah DoSomeWorkAsync(). Melalui model pengaturcaraan tak segerak, kami boleh terus melakukan operasi lain sementara menunggu tugasan selesai, meningkatkan kelajuan tindak balas program.

2. Pengaturcaraan serentak
Apabila memproses sejumlah besar tugas, pengaturcaraan serentak boleh memanfaatkan sepenuhnya kelebihan pemproses berbilang teras dan meningkatkan kelajuan pemprosesan tugas. Dalam C#, anda boleh menggunakan benang, kumpulan benang, perpustakaan selari tugas, dll. untuk melaksanakan pengaturcaraan serentak.

1. Thread
   Menggunakan benang untuk pengaturcaraan serentak ialah kaedah yang paling asas. Dengan mencipta berbilang utas dan memberikan tugasan kepada utas ini untuk pelaksanaan serentak, kecekapan pemprosesan boleh dipertingkatkan. Berikut ialah contoh penggunaan benang:

static void DoSomeWork()
{
    Console.WriteLine("线程开始执行任务");
  
    // 模拟耗时操作
    Thread.Sleep(1000);
  
    Console.WriteLine("线程任务执行完毕");
}

static void Main(string[] args)
{
    Console.WriteLine("开始执行任务");
  
    // 创建线程
    Thread thread = new Thread(DoSomeWork);
  
    // 启动线程
    thread.Start();
  
    Console.WriteLine("任务执行中");
  
    // 等待线程执行完毕
    thread.Join();
  
    Console.WriteLine("任务执行完毕");
  
    // 等待用户输入，防止控制台窗口关闭
    Console.ReadLine();
}

Dalam kod di atas, kami melaksanakan tugas dengan mencipta urutan baharu dan memulakannya. Melalui kaedah Join() thread, kami boleh memastikan bahawa kami menunggu thread selesai sebelum meneruskan pelaksanaan thread utama.

2. Kolam Benang
   Menggunakan kumpulan benang ialah kaedah yang lebih cekap dan terurus secara automatik. Kumpulan benang mencipta satu set benang apabila aplikasi dimulakan dan menggunakan semula urutan ini untuk melaksanakan tugas. Berikut ialah contoh penggunaan kumpulan benang:

static void DoSomeWork()
{
    Console.WriteLine("线程开始执行任务");
  
    // 模拟耗时操作
    Thread.Sleep(1000);

    Console.WriteLine("线程任务执行完毕");
}

static void Main(string[] args)
{
    Console.WriteLine("开始执行任务");
  
    // 使用线程池执行任务
    ThreadPool.QueueUserWorkItem(_ => DoSomeWork());
  
    Console.WriteLine("任务执行中");
  
    // 等待用户输入，防止控制台窗口关闭
    Console.ReadLine();
}

Dalam kod di atas, kami mewakilkan tugas kepada kumpulan benang untuk dilaksanakan melalui kaedah ThreadPool.QueueUserWorkItem(). Kumpulan benang secara automatik akan memperuntukkan benang terbiar untuk melaksanakan tugas, menghapuskan keperluan untuk membuat dan memulakan benang secara manual.

3. Task Parallel Library
   The Task Parallel Library (TPL) ialah model pengaturcaraan serentak lanjutan yang diperkenalkan dalam .NET Framework 4. Ia menyediakan satu siri kelas dan kaedah untuk memudahkan pengendalian tugas serentak. Berikut ialah contoh penggunaan perpustakaan selari tugas:

static void DoSomeWork()
{
    Console.WriteLine("任务开始执行");
  
    // 模拟耗时操作
    Thread.Sleep(1000);
  
    Console.WriteLine("任务执行完毕");
}

static void Main(string[] args)
{
    Console.WriteLine("开始执行任务");
  
    // 创建任务
    Task task = new Task(DoSomeWork);
  
    // 启动任务
    task.Start();
  
    Console.WriteLine("任务执行中");
  
    // 等待任务执行完毕
    task.Wait();

    Console.WriteLine("任务执行完毕");
  
    // 等待用户输入，防止控制台窗口关闭
    Console.ReadLine();
}

Dalam kod di atas, kami melaksanakan kerja dengan mencipta tugasan (Task). Mulakan tugas dengan memanggil kaedah Mula() dan kemudian gunakan kaedah Tunggu() untuk menunggu tugasan selesai.

3 Pengagihan dan penyelesaian tugas
Dalam aplikasi sebenar, kami mungkin perlu memproses sejumlah besar tugas dan mengagihkan tugas ini kepada berbilang rangkaian atau kumpulan benang untuk pelaksanaan serentak. Berikut ialah contoh kod untuk menunjukkan cara menggunakan model pengaturcaraan tak segerak dan pengaturcaraan serentak untuk mengendalikan pengagihan dan penyelesaian tugas:

static async Task<int> DoSomeWorkAsync()
{
    // 模拟一个耗时操作
    await Task.Delay(1000);
    return 42;
}

static async Task Main(string[] args)
{
    Console.WriteLine("开始执行任务");

    var tasks = new List<Task<int>>();

    for (int i = 0; i < 10; i++)
    {
        tasks.Add(DoSomeWorkAsync());
    }

    // 等待所有任务完成
    await Task.WhenAll(tasks);

    Console.WriteLine("所有任务执行完毕");

    // 输出任务结果
    foreach (var task in tasks)
    {
        Console.WriteLine("任务结果：" + task.Result);
    }

    // 等待用户输入，防止控制台窗口关闭
    Console.ReadLine();
}

Dalam kod di atas, kami menggunakan model pengaturcaraan tak segerak untuk mencipta berbilang tugas, dan tambahkan tugasan ini pada senarai tugasan. Tunggu semua tugasan diselesaikan dengan memanggil kaedah Task.WhenAll(), dan kemudian melintasi senarai tugasan untuk mengeluarkan hasil tugasan.

Kesimpulan:
Melalui model pengaturcaraan tak segerak dan pengaturcaraan serentak, kami boleh meningkatkan prestasi dan kecekapan program apabila memproses sejumlah besar tugas. Model pengaturcaraan tak segerak membolehkan kami meneruskan operasi lain sementara menunggu tugasan selesai, manakala pengaturcaraan serentak memanfaatkan sepenuhnya pemproses berbilang teras untuk meningkatkan kelajuan pelaksanaan tugas. Dalam aplikasi praktikal, kita boleh memilih kaedah yang sesuai untuk mengagihkan tugas dan menyelesaikan masalah mengikut situasi tertentu. Kod sampel di atas menyediakan beberapa kaedah dan teknik asas, tetapi aplikasi sebenar mungkin memerlukan kaedah pemprosesan yang lebih terperinci dan kompleks, yang perlu dilaraskan dan dioptimumkan mengikut situasi tertentu.

Rujukan:

1. C# Model pengaturcaraan tak segerak: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/ concepts /async/
2. C# Pengaturcaraan selari: https://docs.microsoft.com/en-us/dotnet/standard/parallel-programming/

Atas ialah kandungan terperinci Cara menggunakan model pengaturcaraan tak segerak dan pengaturcaraan serentak untuk mengendalikan pengagihan tugas dan penyelesaian dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!