View source for Java/fr

<languages />
[[Category:Software]]
Java est un langage de programmation de haut niveau orienté objet créé en 1995 par Sun Microsystems (rachetée en 2009 par Oracle). L'objectif central de Java est que les logiciels écrits dans ce langage obéissent au principe ''write once, run anywhere'' et sont très facilement portables sur plusieurs systèmes d’exploitation par le fait que le code source Java se compile en code octal (''bytecode'') pouvant être exécuté sur un environnement Java (JVM pour ''Java virtual machine''); différentes architectures et plateformes peuvent donc constituer un environnement uniforme. Cette caractéristique fait de Java un langage populaire dans certains contextes et notamment pour l'apprentissage de la programmation. Même si l'accent n'est pas sur la performance, il existe des moyens d'augmenter la vitesse d'exécution et le langage a connu une certaine popularité auprès des scientifiques dans des domaines comme les sciences de la vie, d'où sont issus par exemple les outils d'analyse génomique [https://software.broadinstitute.org/gatk/ GATK] du Broad Institute. Le but de cette page n'est pas d'enseigner le langage Java, mais de fournir des conseils et suggestions pour son utilisation dans l'environnement CHP de Calcul Canada. 

Calcul Canada met à la disposition des utilisateurs plusieurs environnements Java via la commande <tt>module</tt>. En principe, vous aurez un seul module Java chargé à la fois. Les principales commandes associées aux modules Java sont&nbsp;:
* <tt>java</tt> pour lancer un environnement Java;
* <tt>javac</tt> pour appeler le compilateur Java qui convertit un fichier source Java en bytecode. 

Les logiciels Java sont fréquemment distribués sous forme de fichiers JAR portant le suffixe <tt>jar</tt>. Pour utiliser un logiciel Java, utilisez la commande 
{{Commande|java -jar file.jar}}   

==Parallélisme==

===Fils d'exécution=== 
Java permet la programmation avec fils, éliminant ainsi le recours à des interfaces et librairies comme OpenMP, pthreads et Boost qui sont nécessaires avec d'autres langages. L'objet Java principal pour traiter la concurrence est la classe <tt>Thread</tt>; on peut l'employer en fournissant une méthode <tt>Runnable</tt> à la classe <tt>Thread</tt> standard ou encore en définissant la classe <tt>Thread</tt> comme sous-classe, comme démontré ici&nbsp;:    
{{Fichier
  |name=thread.java
  |lang="Java"
  |contents=
public class HelloWorld extends Thread {
        public void run() {
            System.out.println("Hello World!");
        }
        public static void main(String args[]) {
            (new HelloWorld()).start();
        }
}
}}
Cette approche est généralement la plus simple, mais présente cependant le désavantage de ne pas permettre l'héritage multiple; la classe qui implémente l'exécution concurrente ne peut donc pas avoir en sous-classe une autre classe potentiellement plus utile. 

=== MPI === 
On utilise souvent la librairie [http://mpj-express.org/ MPJ Express] pour obtenir un parallélisme de type MPI.

== Pièges ==

<div class="mw-translate-fuzzy">
===Mémoire === 
Java utilise un mécanisme de désallocation automatique de la mémoire (''garbage collector'') pour identifier les variables qui ne s'appliquent pas et retourner la mémoire qui leur est associée au système d'exploitation; plusieurs programmes Java nécessitent tout de même beaucoup de mémoire pour bien fonctionner. Au lancement avec la commande <tt>java</tt>, la taille du tas Java (''heap size'') est initialement fixée à 1/64e avec un maximum de 1/4 de la mémoire physique. Ces proportions, et particulièrement la valeur maximale, peuvent s'avérer inadéquates et font en sorte qu'une part importante de la mémoire reste inutilisée. Pour éviter cette situation, spécifiez la quantité maximale de mémoire à utiliser avec la commande

{{Commande|java -Xmx8192m -jar file.jar}}  
Dans cet exemple, le maximum est de 8192Mo (8Go). Indiquez la taille initiale du tas avec l'argument <tt>Xms</tt> et voyez toutes les options en ligne de commande que la JVM exécutera avec l'indicateur <tt>-XX:+PrintCommandLineFlags</tt>.
</div>

When the Java VM starts, it sets two memory parameters according to the amount of physical rather than available memory as follows:
* Initial heap size of 1/64 of physical memory
* Maximum heap size of 1/4 of physical memory

On a system with a lot of physical memory, the 1/4 can easily exceed default the memory limits imposed by a shell or by the scheduler, and Java will fail with messages like these
  Could not reserve enough space for object heap
  There is insufficient memory for the Java Runtime Environment to continue.

The two run-time memory parameters, however, can be explicitly controlled on the command line by following either syntax below:
  java -Xms256m -Xmx4g -version
or
  java -XX:InitialHeapSize=256m -XX:MaxHeapSize=4g -version

You can see all the command line options the JVM is going to run with by specifying the following flag <code>-XX:+PrintCommandLineFlags</code>, like so:
<pre>
$ java -Xms256m -Xmx4g -XX:+PrintCommandLineFlags -version
-XX:InitialHeapSize=268435456 -XX:MaxHeapSize=4294967296 -XX:ParallelGCThreads=4 -XX:+PrintCommandLineFlags -XX:+UseCompressedOops -XX:+UseParallelGC
</pre>

Vous pouvez utiliser la variable d'environnement <tt>_JAVA_OPTIONS</tt> pour configurer les options d'exécution plutôt que de les spécifier en ligne de commande. Ceci s'avère utile quand des appels multiples sont lancés ou qu'un programme est appelé par un autre programme Java. Voici un exemple : 
{{Commande|export _JAVA_OPTIONS{{=}}"-Xms256m -Xmx2g"}}


À l'exécution, le programme émet un message de diagnostic semblable à ''Picked up _JAVA_OPTIONS''; ceci indique que les options ont été prises en compte.

N'oubliez pas que l'instance Java crée elle-même une réserve d'utilisation de la mémoire. Nous recommandons que la limite par tâche soit fixée à 1 ou 2Go de plus que la valeur de l'option <tt>-Xmx</tt>.

<div class="mw-translate-fuzzy">
===Garbage Collector (GC)=== 
Que la tâche soit ou non multifil, Java utilise par défaut le mécanisme de désallocation parallèle ''Garbage Collector'' avec autant de fils que le nombre de cœurs CPU dans le nœud. Chacun des fils du GC consomme une portion de la mémoire physique proportionnelle au total. Nous recommandons fortement de définir le même nombre de fils pour le GC que le nombre de cœurs CPU demandé à l'ordonnanceur lors de la soumission de votre script, par exemple <tt>-XX:ParallelGCThreads=12</tt>. Même si la tâche est parallèle, vous pouvez invoquer le GC série avec l'option <tt>-XX:+UseSerialGC</tt>.
</div>

By default, the Java VM uses a parallel garbage collector (GC) and sets a number of GC threads equal to the number of CPU cores on a given node, whether a Java job is threaded or not. Each GC thread consumes memory. Moreover, the amount of memory each GC thread consumes is proportional to the amount of physical memory. Therefore, we highly recommend matching the number of GC threads to the number of CPU cores you requested from the scheduler in your job submission script, like so <tt>-XX:ParallelGCThreads=12</tt> for example. You can also use the serial garbage collector by specifying the following option <tt>-XX:+UseSerialGC</tt>, whether your job is parallel or not.

===Mot-clé <tt>volatile</tt> === 
Le sens de ce mot-clé est très différent de celui du même terme utilisé en programmation C/C++. La valeur d'une variable Java ayant cet attribut est toujours lue directement de la mémoire principale et toujours écrite directement dans la mémoire principale; toute modification à la variable sera donc visible par tous les autres fils. Dans certains contextes cependant, <tt>volatile</tt> ne suffit pas à empêcher les situations de compétition (''race conditions'') et <tt>synchronized</tt> est nécessaire pour maintenir la cohérence du programme.

==Références== 
OAKS, Scott et Henry Wong, Java Threads: Understanding and Mastering Concurrent Programming, 3e édition, O'Reilly, 2012.