Aux débuts de FORTRAN et de BASIC, pratiquement tous les programmes étaient écrits avec des déclarations GOTO. Le résultat était un code spaghetti et la solution était une programmation structurée.
De même, les pointeurs peuvent avoir des caractéristiques difficiles à contrôler dans nos programmes. C ++ a commencé avec beaucoup de pointeurs, mais l'utilisation de références est recommandée. Des bibliothèques telles que STL peuvent réduire certaines de nos dépendances. Il existe également des idiomes pour créer des pointeurs intelligents présentant de meilleures caractéristiques, et certaines versions de C ++ permettent des références et du code géré.
Les pratiques de programmation telles que l'héritage et le polymorphisme utilisent beaucoup de pointeurs dans les coulisses (comme pour la programmation structurée, le code est rempli d'instructions de branche). Des langages tels que Java éliminent les pointeurs et utilisent la récupération de place pour gérer les données allouées dynamiquement au lieu de dépendre des programmeurs pour qu'ils correspondent à leurs nouvelles instructions et à leurs instructions delete.
Dans ma lecture, j'ai vu des exemples de programmation multi-processus et multi-threads qui ne semblent pas utiliser de sémaphores. Utilisent-ils la même chose avec des noms différents ou disposent-ils de nouvelles méthodes pour structurer la protection des ressources contre les utilisations simultanées?
Par exemple, OpenMP est un exemple spécifique de système de programmation multithread avec des processeurs multicœurs. Il représente une région critique comme suit, sans l'utilisation de sémaphores, qui semblent ne pas être inclus dans l'environnement.
th_id = omp_get_thread_num();
#pragma omp critical
{
cout << "Hello World from thread " << th_id << '\n';
}
Cet exemple est un extrait de: http://en.wikipedia.org/wiki/OpenMP
Sinon, une protection similaire des threads utilisant des sémaphores avec les fonctions wait () et signal () pourrait ressembler à ceci:
wait(sem);
th_id = get_thread_num();
cout << "Hello World from thread " << th_id << '\n';
signal(sem);
Dans cet exemple, les choses sont assez simples, et une simple revue suffit pour montrer que les appels wait () et signal () sont appariés et même avec beaucoup de simultanéité, la sécurité des threads est assurée. Mais d'autres algorithmes sont plus compliqués et utilisent plusieurs sémaphores (binaires et compteurs) répartis sur plusieurs fonctions avec des conditions complexes pouvant être appelées par de nombreux threads. Il peut être difficile de gérer les conséquences d’une impasse ou de l’absence de sécurité.
Est-ce que ces systèmes comme OpenMP éliminent les problèmes de sémaphores?
Est-ce qu'ils déplacent le problème ailleurs?
Comment transformer mon sémaphore préféré en utilisant un algorithme pour ne plus utiliser de sémaphores?