Techniques de programmation asynchrone en C++

C++ est un langage de programmation populaire largement utilisé dans divers types d'applications, en particulier celles qui fonctionnent de manière plus complexe ou qui ont des exigences élevées en matière de ressources système. Par conséquent, les compétences en programmation asynchrone sont devenues de plus en plus importantes dans le développement C++ ces dernières années. Dans cet article, nous explorerons comment utiliser C++ pour la programmation asynchrone.

Contexte de la programmation asynchrone

Pour certaines tâches fastidieuses et chronophages, le modèle de programmation synchrone ne peut pas répondre aux besoins. Le système d'exploitation définit souvent ces tâches en mode asynchrone afin d'utiliser les ressources système plus efficacement. Avec le modèle de programmation asynchrone, un programme peut exécuter plusieurs tâches en parallèle sans attendre la fin de la tâche précédente. Cela contribue à améliorer les performances globales du programme.

Conseils de programmation asynchrone

Lorsque nous effectuons une programmation asynchrone en C++, nous devons utiliser une bibliothèque asynchrone. Parmi eux, le standard C++11 inclut une bibliothèque asynchrone, std::async, qui peut exécuter des fonctions dans des threads autres que le thread principal. Le processus spécifique d'utilisation de la fonction std::async est le suivant :

1 Créez une tâche asynchrone : std::future object.

2. Pour exécuter une fonction dans une tâche asynchrone, utilisez la fonction std::async pour spécifier la fonction et les paramètres.

3. Exécutez d'autres tâches dans le thread principal et attendez la fin de la tâche asynchrone avant d'obtenir les résultats.

Ce qui suit est un exemple de code :

//Inclure le fichier d'en-tête

include

include

//Tâche asynchrone
int foo(int x) {

return x * x; 

}

/ /Main function
int main() {

//创建异步任务 
std::future<int> result = std::async(foo,2);

//在此期间执行其他任务 
std::cout << "Main Task Finished" << std::endl;

//等待异步任务完成 
int r = result.get();

//输出异步任务结果 
std::cout << "Result is " << r << std::endl;

}

Il convient de noter qu'en attendant la fin de la tâche asynchrone dans le thread principal, le thread principal sera bloqué. Par conséquent, nous pouvons utiliser l'un des types d'énumération std::future_status, à savoir std::future_status::ready, pour détecter si la tâche asynchrone est terminée, comme suit :

//Détecter si la tâche asynchrone est terminée
if ( result.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {

//异步任务已完成

}

De plus, nous pouvons également utiliser std::promise et std::future ensemble, Pour répondre à des besoins de programmation asynchrone plus précis. Par exemple, dans la programmation multithread, nous devrons peut-être attendre la fin d'un thread avant d'effectuer d'autres tâches. À ce stade, nous pouvons utiliser std::promise et std::future pour implémenter le mécanisme de sémaphore :

//. Contient le fichier d'en-tête

include

include

include

include

//Tâche asynchrone
void foo(std::promise &p ) {

std::this_thread::sleep_for(std::chrono::seconds(2)); //模拟长时间的任务
p.set_value(); //使用set_value()将结果返回给主线程 

}

//Main function
int main() {

//创建promise对象 
std::promise<void> p; 

//获取future对象 
std::future<void> f = p.get_future();

//在单独的线程中运行异步任务 
std::thread t(foo, std::ref(p));

//在此期间执行其他任务
std::cout << "Main Task Started" << std::endl;

//等待异步任务完成 
f.wait();

//输出结果 
std::cout << "Main Task Finished" << std::endl;

//等待异步线程完成 
t.join();

}

Dans cet exemple, nous utilisons std::promise pour transmettre une valeur de sémaphore (c'est-à-dire void) au thread asynchrone, après le le thread asynchrone termine la tâche, utilisez la fonction set_value() pour renvoyer la valeur du sémaphore au thread principal. Le thread principal doit attendre la fin du thread asynchrone avant de pouvoir poursuivre son exécution.

Résumé

La programmation asynchrone est une compétence importante en programmation C++, qui peut améliorer les performances globales et la simultanéité du programme. Dans cet article, nous présentons les principes de base de la programmation asynchrone en C++ et montrons plusieurs exemples de codes pertinents. Si vous souhaitez améliorer les performances de votre programme ou devez effectuer une programmation multithread, les compétences en programmation asynchrone sont l'une des technologies de base que vous devez maîtriser.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!