# Cour -- Pratique de la concurrence

###### tags `cour` `M1 S1` `Concurrence`
[Somaire](IAsAMpizSpawifCj1gZ__g#)
> [time= 16 sept 2020]

[TOC]

## class Thread
[man page Thread](https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html)\

- **Thread(); Thread(Runable runable)**\
crée l'objet thread (avec *new*)
- **run()**\
code à executer
- **start()**\
démare le thread (et le retourne immédiatement)
- **join()**\
permet d'attendre la fin du thread
- **yield()**\
redonne la main au scheduler
- **sleep(long t)**\
attend pendant un temps *t* (en milliseconde)
- **interupt / interupted()**
intérompt le thread
- **setPriorty / getPriority**\
Donne la priorité du thread
- **setDaemon/isDeamon**\
dit si le thread est en *deamon* ou en *user*

L'execution des threads sont ++asynchrones++ et ++concurrentes++.

++asynchrones++: pas de garantie de l'ordre des threads

public class MyClass extends Thread
{
    public void run()
    {
    //...
    }
}
public class Main
{
    public static void main(String args[])
    {  
        MyClass thread = new MyClass(); 
        thread.start();  
     }  
}

## Interface Runnable
[Runnable man Page](https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html
)
- *run*\
Méthode à implémenter

Avec un Runable on peut crée un thread.

public class MyClass implements Runnable
{
    public void run()
    {
    //...
    }
}
public class Main
{
    public static void main(String args[])
    {  
        MyClass runnable = new MyClass(); 
        Thread t =new Thread(runnable);  
        t.start();  
     }  
}

## Lecture et écriture

En java il y a **atomicité** en lecture écriture pour:
- les variables des types primitifs **sauf** ++long++ et ++double++
- pour les variables déclarées comme volatile *(pas d'optimisation de code)*

> [time= 22 sept 2020]

## Verrous / lock
On peux vérouiller une **expression** dans l'instruction déclarer:
**synchronized(expr){instruction}**

public class MyClassSynchonizer {
    private final Object monMonitor = new Object();
    
    public void maMethode1() 
    {
        synchronized(monMonitor) 
        {
        // ...
        }
  }
    public synchronized void maMethode2() 
    {
    //...    
    }

}

Ou sur une méthode.

[tuto synchronize java](https://docs.oracle.com/javase/tutorial/essential/concurrency/sync.html)

## synchronization
[man page Object](https://docs.oracle.com/javase/10/docs/api/java/lang/Object.html)\
attend que une condition soir réaliser pour poursuivre
- wait\
On attend (utiliser la condition avec un while)
- notify\
reveil 1 processus
- notifyAll\
reveil tout les processus

## Objet concurent de haut niveau
- Java.utils.concurrent.lock
- wait/notify conditions
- Exhanger, Barrières, sémaphores
- JAVA.util.concurrent.atomic
- Collection concurent

## Lock / Condition
Interface Lock:
- lock()
- unlock()
- trylock()
- newConditions()

Implémentée apr
- Class ReentrantLock
- Class ReentrantReadWriteLock

Interface condition:
- await()
- signal()
- signalAll()\
Associcée à un lock

[man page ReentrantLock](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReentrantLock.html)

## Exchanger
Permet d'échanger des valeurs

## Barrières
On utilise un compteur quand le compteur est a 0 la barière est levé.
On fait attendre tout le monde à la barriere, pour qu'il passe tous d'un coup!

## Cyclic barriere

## phaser

## sémaphore
Initialiser a une valeur n, nombre de permis qui peuvent passer.

méthode:
- aquire()
- release()

## Atomic

## Callable et Future
thread qui retourne des valeurs

## Executor
Execute plusieurs runable

[man page Executor](https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)
## ForkJoinPool