{"id":63,"date":"2017-09-09T15:36:30","date_gmt":"2017-09-09T15:36:30","guid":{"rendered":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/?p=63"},"modified":"2023-04-03T16:12:43","modified_gmt":"2023-04-03T16:12:43","slug":"programmation-concurrente","status":"publish","type":"post","link":"https:\/\/wp-systeme.lip6.fr\/potop-butucaru\/2017\/09\/09\/programmation-concurrente\/","title":{"rendered":"Programmation Concurrente"},"content":{"rendered":"
\n
\n

Introduction<\/h1>\n<\/section>\n
Dans une ex\u00e9cution s\u00e9quentielle, une grande partie du temps est pass\u00e9e \u00e0 attendre.Exemple: lors de l’attente de r\u00e9ception d’un message dans un socket, lors de la lecture d’un fichier, …<\/small><\/p>\n<\/section>\n
\n
\n

Lecture de deux sockets :<\/p>\n

\r\nSocket s1 = new Socket(host, port);\r\nSocket s2 = new Socket(host2, port2);\r\nInputStream in1 = s1.getInputStream();\r\nInputStream in2 = s2.getInputStream();\r\nOutputStream out = s2.getOutputStream();\r\n\r\nint a = in1.read();\r\nint b = in2.read();\r\nint c = a+b;\r\nout.write(c);\r\n                        <\/code><\/pre>\n<\/div>\n
<\/object><\/section>\n
C’est pourquoi, il est souvent utile (et m\u00eame parfois m\u00eame n\u00e9cessaire) d’ex\u00e9cuter des actions en parall\u00e8le.<\/section>\n
\n
Exemple de l’architecture client-serveur<\/h2>\n
Dans une architecture client\/serveur, deux clients qui veulent communiquer ensemble, doivent passer par un serveur.<\/p>\n
<\/object><\/section>\n
\n
Exemple de l’architecture client-serveur<\/h2>\n
\r\n\r\nServerSocket serveur = new ServerSocket(8080);\r\nSocket alice = server.accept();\r\nSocket bob = server.accept();\r\n\r\nScanner       aliceIn  = new Scanner(alice.getInputStream());\r\nScanner       bobIn    = new Scanner(bob.getInputStream());\r\n\r\nPrinterWriter aliceOut = new PrinterWriter(\r\n                            alice.getOutputStream(), true);\r\nPrinterWriter bobOut   = new PrinterWriter(\r\n                            bob.getOutputStream(), true);\r\n\r\n\/\/ ....\r\n                        <\/code><\/pre>\n
\r\n\r\nServerSocket serveur = new ServerSocket(8080);\r\nSocket alice = server.accept();\r\nSocket bob = server.accept();\r\n\r\n\/\/ ....\r\n\r\nString message = aliceIn.readLine();\r\nbobOut.println(message);\r\n\r\nmessage = bobIn.readLine();\r\naliceOut.println(message);\r\n                        <\/code><\/pre>\n<\/section>\n
\n
\r\n\r\nString message = aliceIn.readLine();\r\nbobOut.println(message);\r\nmessage = bobIn.readLine();\r\naliceOut.println(message);\r\n\r\n                        <\/code><\/pre>\n
<\/object><\/section>\n
\n
Serveur multithread\u00e9<\/h2>\n
<\/object><\/section>\n
\n
Calculs intensifs<\/h2>\n
En plus de la n\u00e9cessit\u00e9 d’utiliser les threads pour pouvoir faire plusieurs choses en m\u00eame temps. Il est parfois utile de pouvoir parall\u00e9liser un calcul pour utiliser plus efficacement les mutliple coeurs du CPU (pour effectuer un calcul plus vite).<\/p>\n
Dans ce context le probl\u00e8me est parfois plus compliqu\u00e9 car des threads travaillant sur des donn\u00e9es communes doivent faire attention lorsqu’ils acc\u00e8dent de mani\u00e8re concurrente<\/b>au m\u00eame donn\u00e9es.<\/p>\n<\/section>\n<\/section>\n
\n
\n
Les processus et les threads<\/h1>\n<\/section>\n
\n
Diff\u00e9rences entre processus et threads<\/h2>\n
Un processus<\/b> est un programme qui s’ex\u00e9cute. Il poss\u00e8de son propre espace m\u00e9moire.<\/p>\n
Un thread<\/b> est un ensemble d’instructions qui s’ex\u00e9cutent (un sous-ensemble des instructions du processus en cours). Il utilise le m\u00eame espace m\u00e9moire et les m\u00eames resources que le processus dans lequel il s’ex\u00e9cute. <\/span>Cependant, il peut s’ex\u00e9cuter de mani\u00e8re ind\u00e9pendantes de (parfois en m\u00eame temps que) son processus (possiblement sur un coeur diff\u00e9rent du CPU ).<\/span><\/p>\n<\/section>\n
\n
Le processus principal<\/h2>\n
La class Runtime<\/code> d\u00e9finie un objet qui repr\u00e9sente un environement d’ex\u00e9cution. On obtient l’environement de l’application courante \u00e0 l’aide de la m\u00e9thode statique Runtime.getRuntime()<\/code><\/p>\n
\r\nRuntime monApplication = Runtime.getRuntime();\r\n                      <\/code><\/pre>\n<\/section>\n
\n
Cr\u00e9ation de processus<\/h2>\n
A partir d’un objet Runtime<\/code> on peut cr\u00e9er des processus (objects de type Process<\/code>) avec la m\u00e9thode exec<\/code>. Ou bien en utilisant la classe ProcessBuilder<\/code>.<\/span><\/p>\n
\r\n\r\nRuntime monApplication = Runtime.getRuntime();\r\n\r\nProcess p1 = monApplication.exec(\"cat index.html\");\r\nProcess p2 = monApplication.exec(\"python\", \"script.py\");\r\n\r\nProcessBuilder pb = new ProcessBuilder(\"espeak\", \"hello, how are you?\");\r\nProcess p3 = pb.start();\r\npb = new ProcessBuilder(\"say\", \"Bonjour tout le monde!\");\r\nProcess p4 = pb.start();\r\n\r\n\/\/ Waits for the command to finish.\r\np1.waitFor();\r\np2.waitFor();\r\np3.waitFor();\r\np4.waitFor();\r\n\r\n                        <\/code><\/pre>\n<\/section>\n
\n
Communication avec un processus<\/h2>\n
Les m\u00e9thodes getOutputStream()<\/code>, getInputStream()<\/code>, et getErrorStream()<\/code> permettent de communiquer avec le processus.<\/p>\n
\r\n\r\nProcess p2 = monApplication.exec(\"python script.py\");\r\nBufferedReader in = new BufferedReader(new InputStreamReader(p.getErrorStream()));\r\nString line;\r\nwhile ((line = in.readLine()) != null) {\r\n      System.out.println(line);\r\n}\r\n                            <\/code><\/pre>\n
\r\n\/usr\/local\/bin\/python: can't open file 'script.py': [Errno 2] No such file or directory\r\n                            <\/code><\/pre>\n<\/section>\n
\n
Avantage des Threads<\/h2>\n
Dans un processus Java, on peut cr\u00e9er plusieurs fils d’ex\u00e9cution (threads) internes<\/p>\n