Bagaimana untuk melaksanakan pengaturcaraan tak segerak dalam kod C++?

Bagaimana untuk melaksanakan pengaturcaraan tak segerak dalam kod C++?

Dalam bidang pembangunan perisian, pengaturcaraan tak segerak (Asynchronous Programming) telah menjadi salah satu kemahiran yang diperlukan. Ia boleh mengimbangi prestasi operasi intensif CPU dan operasi intensif IO dengan lebih baik, membolehkan kod program dilaksanakan secara serentak atau selari, dengan itu meningkatkan kelajuan tindak balas dan prestasi keseluruhan program. Pada masa ini, pengaturcaraan tak segerak digunakan secara meluas dalam banyak platform dan bahasa pengaturcaraan. Bahasa C++ ialah bahasa pengaturcaraan berprestasi tinggi, dan mod pengaturcaraan tak segeraknya juga telah digunakan secara meluas dalam banyak projek. Artikel ini akan memperkenalkan kaedah pengaturcaraan tak segerak bagi bahasa C++, dengan harapan dapat membantu semua orang menguasai pengaturcaraan tak segerak.

Kaedah pengaturcaraan tak segerak dalam C++11

Piawaian C++11 memperkenalkan std::async untuk pengaturcaraan tak segerak. Fungsi std::async digunakan untuk memulakan utas baharu dan mengembalikan objek std::depan yang mewakili hasil pengiraan tak segerak. Fungsi ini ditakrifkan seperti berikut:

template< class Function, class... Args >
future<typename result_of<Function(Args...)>::type>
async( launch policy, Function&& f, Args&&... args );

Antaranya, dasar parameter ialah strategi pelancaran Pilihannya ialah std::launch::async dan std::launch::deferred dengan segera, dan yang terakhir bermaksud untuk menangguhkan permulaan pengiraan tak segerak Parameter f ialah fungsi atau objek fungsi yang akan dilaksanakan;

Kod contoh penggunaan std::async untuk pengaturcaraan tak segerak adalah seperti berikut:

#include <iostream>
#include <future>
#include <chrono>
#include <thread>

using namespace std;

int async_func(int x, int y)
{
    cout << "async_func start." << endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    cout << "async_func end." << endl;
    return x + y;
}

int main()
{
    std::future<int> result = std::async(std::launch::async, async_func, 1, 2);
    cout << "main func start." << endl;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    cout << "main func end." << endl;
    int res = result.get();
    cout << "result: " << res << endl;

    return 0;
}

Dalam kod ini, kami menggunakan std::async untuk membuka benang pengiraan tak segerak, laksanakan fungsi async_func secara tak segerak dan masukkan nilai ​​parameter x dan y masing-masing Untuk 1 dan 2, hasil pengiraan akhirnya dikembalikan. Dalam utas utama, kami mula-mula berhenti seketika selama 2 saat, dan selepas utas pengiraan tak segerak selesai berjalan, kami memperoleh hasil pengiraan dan mencetaknya.

Dengan menjalankan kod di atas, hasil output adalah seperti berikut:

async_func start.
main func start.
async_func end.
main func end.
result: 3

Ia boleh dilihat daripada hasil output bahawa semasa proses pengiraan tak segerak, utas utama tidak akan menyekat, tetapi akan terus melaksanakan kod berikutnya. Di samping itu, perlu diperhatikan bahawa jika program membuang pengecualian semasa pengiraan tak segerak, jika pengecualian tidak dikendalikan, program akan ranap.

Kaedah pengaturcaraan tak segerak pemasa dalam C++

Selain menggunakan std::async untuk pengaturcaraan asynchronous, C++ juga menyediakan beberapa kaedah pengaturcaraan tak segerak lain, seperti menggunakan pemasa sistem untuk pengaturcaraan tak segerak. Pemasa ialah mekanisme biasa dalam sistem pengendalian, digunakan untuk mencetuskan peristiwa atau melaksanakan tugas pada selang masa yang tetap. Dalam C++, kita boleh menggunakan fungsi yang berkaitan dalam perpustakaan std::chrono dan std::thread untuk melaksanakan pengaturcaraan asynchronous pemasa, seperti yang ditunjukkan di bawah:

#include <iostream>
#include <chrono>
#include <thread>

void timer_func()
{
    std::cout << "timer func called." << std::endl;
}

int main()
{
    int delay_time = 200;
    std::chrono::milliseconds delay(delay_time);
    while(true)
    {
        std::cout << "wait for " << delay_time << " milliseconds." << std::endl;
        std::this_thread::sleep_for(delay);
        timer_func();
    }

    return 0;
}

Dalam atur cara ini, kita menggunakan fungsi std::this_thread::sleep_for , mensimulasikan kelewatan 20 milisaat, dan selepas kelewatan tamat, fungsi timer_func dicetuskan, merealisasikan pengaturcaraan tak segerak pemasa. Dengan menjalankan kod di atas, masa menunggu boleh dicetak secara berterusan dalam terminal, dan "fungsi pemasa dipanggil secara berkala."

Perlu diingatkan bahawa ketepatan dan prestasi pemasa mudah dipengaruhi oleh pelbagai faktor, seperti beban sistem pengendalian, ketepatan masa sistem, dll. Oleh itu, dalam aplikasi sebenar, jika terdapat keperluan masa nyata yang khusus, beberapa pengoptimuman dan pelarasan perlu dibuat.

Kesimpulan

Pengaturcaraan tak segerak telah menjadi salah satu kemahiran penting dalam pembangunan perisian. Dalam bahasa C++, kita boleh menggunakan mekanisme seperti std::async dan pemasa sistem untuk melaksanakan pengaturcaraan tak segerak. Dalam pengaturcaraan sebenar, menggunakan pengaturcaraan tak segerak boleh menggunakan CPU berbilang teras dengan lebih baik, meningkatkan prestasi selari atau serentak kod dan mengurangkan masa tindak balas kod. Artikel ini hanya memperkenalkan pengetahuan asas pengaturcaraan tak segerak Aplikasi sebenar perlu dilengkapkan dengan mekanisme multi-threading, mekanisme penyegerakan benang dan teknologi lain. Aplikasi praktikal memerlukan pemahaman yang mendalam dan penguasaan teknologi berkaitan untuk mengelakkan ralat program dan masalah prestasi.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan pengaturcaraan tak segerak dalam kod C++?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!