Un thread est l'une des unités d'exécution que peut posséder un programme Java. La Machine Virtuelle Java permet à une application d'exécuter plusieurs threads simultanément.

Chaque thread a une priorité. Les objets Thread avec une priorité élevée sont exécuté avant les threads de basses priorités. Chaque thread peut ou ne peut pas être marqué comme un démon. Lorsque le code d'exécution dans quelques threads crée un nouvel objet Thread, le nouveau thread a sa priorité initialement égale à la priorité créant et est un trhead démon si et seulement si le thread créant et un démon.

Lorsqu'une JVM démarre, il y a un unique thread non-démon (lequel typiquement appele le méthode main de quelques classes désignées). La JVM continue à exécuter les threads jusqu'à l'un des événements suivants :

• La méthode exit de la classe Runtime a été appelée et le gestionnaire de sécurité a permis l'opération à prendre la place.
• Tous les threads qui ne sont pas de démons ont cessé d'être actifs soit en retournant à partir de l'appel à la méthode run ou en lançant une exception qui se propage au-delà de la méthode run.

Il y a deux façons de créer un nouveau thread d'exécution. La première est de déclarer une classe qui est une sous-classe d'un objet Thread. Cette sous-classe doit surcharger la méthode run de la classe Thread. Une instance de la sous-classe peut alors être allouée et démarrée.

Les champs
static int MAX_PRIORITY
Ce champ représente la priorité maximum qu'un thread peut posséder.
static int MIN_PRIORITY
Ce champ représente la priorité minimum qu'un thread peut posséder.
static int NORM_PRIORITY
Ce champ représente la priorité par défaut qui est assignée à un thread.

Les constructeurs
Thread()
alloue un nouvel objet Thread.
Thread(Runnable target)
alloue un nouvel objet Thread en lui fournissant une cible Runnable.
Thread(Runnable target, String name)
alloue un nouvel objet Thread en lui affectant une cible Runnable et un nom.
Thread(String name)
alloue un nouvel objet Thread en lui affectant un nom.
Thread(ThreadGroup group, Runnable target)
alloue un nouvel objet Thread en lui affectant un groupe de threads et une cible Runnable.
Thread(ThreadGroup group, Runnable target, String name)
alloue un nouvel objet Thread à l'aide d'un groupe de threads, d'un objet cible Runnable et de son nom.
Thread(ThreadGroup group, Runnable target, String name, long stackSize)
alloue un nouvel objet Thread à l'aide d'un groupe de threads, d'un objet cible Runnable, de son nom et d'une taille de pile.
Thread(ThreadGroup group, String name)
alloue un nouvel objet Thread.

Les méthodes
static int activeCount()
retourne le nombre de threads actifs dans le groupe de threads du thread courant.
void checkAccess()
détermine si l'objet Thread courant possède la permission de modifier le thread.
int countStackFrames()
Dépréciée. Voir suspend().
static Thread currentThread()
retourne une référence vers l'objet Thread d'exécution courant.
void destroy()
détruit l'objet Thread, sans aucun nettoyage.
static void dumpStack()
imprime une trace de pile de l'objet Thread courant.
static int enumerate(Thread[] tarray)
copie à l'intérieur d'un tableau spécifié chaque thread actif dans le groupe de thread de thread et ses sous-groupes.
ClassLoader getContextClassLoader()
retourne l'objet ClassLoader du contexte pour l'objet Thread.
String getName()
retourne le nom de l'objet Thread.
int getPriority()
retourne la priorité de l'objet Thread.
ThreadGroup getThreadGroup()
retourne le groupe du thread vers lequel l'objet Thread appartient.
static boolean holdsLock(Object obj)
retourne true si et seulement si le thread courant conserve le verrou du moniteur sur l'objet spécifié.
void interrupt()
interrompt l'objet Thread.
static boolean interrupted()
teste si l'objet Thread courant a été interrompu.
boolean isAlive()
teste si l'objet Thread est actif.
boolean isDaemon()
teste si l'objet Thread est un thread démon.
boolean isInterrupted()
teste si l'objet Thread a été interrompu.
void join()
attends pour faire mourrir l'objet Thread.
void join(long millis)
attends au maximum quelques millisecondes pour faire mourrir l'objet Thread.
void join(long millis, int nanos)
attends au maximum quelques millisecondes auxquelles s'ajoutent plusieurs nanosecondes pour faire mourrir l'objet Thread.
void resume()
Déprécié. Risque de blocage.
void run()
si le thread était construit en utilisant un objet Runnable séparé , alors la méthode run() de ce dernier est appelée, autrement cette méthode ne fait et ne retourne rien.
void setContextClassLoader(ClassLoader cl)
fixe l'objet ClassLoader du contexte pour le thread courant.
void setDaemon(boolean on)
désigne l'objet Thread comme soit un thread démon (daemon thread), soit un thread utilisateur (user thread).
void setName(String name)
modifie le nom de l'objet Thread au bénéfice du nouveau nom passé en argument.
void setPriority(int newPriority)
modifie la priorité de l'objet Thread.
static void sleep(long millis)
provoque la mise en sommeil de l'objet Thread courant pendant un certain nombre de millisecondes.
static void sleep(long millis, int nanos)
provoque la mise en sommeil de l'objet Thread courant pendant un certain nombre de millisecondes et de nanosecondes.
void start()
provoque le démarage de l'objet Thread, la JVM appelant la méthode run() de ce thread.
void stop()
Déprécié. Risque de blocage.
void stop(Throwable obj)
Déprécié. Risque de blocage.
void suspend()
Déprécié. Risque de blocage.
String toString()
retourne une représentation sous forme d'un objet String de l'objet Thread incluant le nom, la priorité et le groupe du thread.
static void yield()
provoque la mise en pause temporaire de l'objet Thread courant pour permetre l'exécution d'autres threads.
Les méthodes héritées de la classe racine java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait