1. Concurrence

1.1. Comprendre la programmation concurrente

La  programmation concurrente en informatique est la possibilité d'exécuter plusieurs programmes ou plusieurs parties d'un programme en parallèle sur une même machine. Par exemple, si une tâche consommatrice de temps peut être exécutée d'une manière asynchrone ou en parallèle avec d'autres programmes, alors on améliore l'exécution  et l'interactivité des programmes tournant sur une même machine. L'une des plus grandes difficultés de la programmation concurrente est de maintenir cohérent l'état des objets (au sens instance d'une classe) , même lorsque plusieurs threads les partagent.
Un ordinateur moderne a plusieurs UC ou plusieurs cœurs dans une UC. La capacité de démultiplier ces multi-cœurs peut être la clé pour une possibilité d'exécuter parallèlement un grand nombre de programmes.

1.2. Processus  ou  threads

Les  processus en informatique doivent pouvoir fonctionner indépendamment les uns des autres  au sein d'un programme informatique car en principe chaque processus ne doit pas avoir   accès aux données des autres processus. Les ressources d'un processus, par exemple la mémoire  et le temps CPU, lui sont  sont allouées par le système d'exploitation.
Un thread, appelé aussi processus léger, a sa propre pile d'appels, mais il peut avoir accès aux données partagées d' autres threads.
Toute application Java s'exécute dans un processus et  plusieurs threads peuvent  pour réaliser des  traitements de façon parallèle au sein d'une même application.

2. Les limites et les gains de la concurrence

2.1. La loi d'Amdahl

La programmation concurrente  permet d'exécuter certaines tâches d'un programme plus rapidement; ces tâches sont divisées en sous-tâches et ces sous-tâches sont  exécutées en parallèle. Toutefois le temps global d'exécution  est limité par les parties de la tâche qui peuvent être exécutées en parallèle.
Le gain théorique de performance possible peut être calculé par  la Loi d'Amdahl qui stipule que:
Si F est le pourcentage du programme qui ne peut pas fonctionner en parallèle et N  le nombre de processus, alors le gain de performance maximal est 1/(F + ((1-f) / n)).

2.2. Les problèmes liés à la Concurrence

Les threads ont leur propre pile d'appels, mais ils peuvent aussi avoir accès à des données partagées. Cela crée  deux problèmes essentiels,  à savoir la visibilité et l' accessibilités.
Un problème de visibilité arrive si le thread A lit des données partagées  qui ont été changées postérieurement par un thread B et que le thread A, au moment d'utiliser ces données  ignore ce changement.
Un problème d'accès peut arriver si plusieurs threads  ont accès aux mêmes données au même moment et les changent en même temps.

La visibilité et le problème d'accès aux données partagées peuvent mener à :

• Des erreurs de comportement: dans ce cas le programme ne réagit pas comme il faut lorsqu'il accède aux données et cela peut  provoquer des inter-blocage (deadlocks).
• Problème de sécurité: Le programme peut créer des données incorrectes.