Les méthodes liées au fil de base attendent, informer, notifyAll, le sommeil, le rendement, joindre et ainsi de suite. Procédé de commande du fonctionnement d'un fil, l'état du fil et des changements.

Discussion attente: Méthode d'attente

Discussion appelle la méthode d'attente entrera ATTENDANT état, seul ne reviendra qu'après l'avis d'autres fils ou interrompu. Notez que dans la méthode attente d'appel libère le verrou de l'objet , et par conséquent, la méthode d'attente est généralement utilisé une méthode dans des blocs de synchronisation ou le code de synchronisation.

sommeil du fil: méthode de sommeil

sommeil appel provoque le thread courant pour dormir. Différente de la méthode d'attente à méthode de sommeil ne libère pas le verrou actuellement occupé, provoque le fil dans l'état minutées WAITING, et la méthode d'attente provoque le thread courant pour entrer dans l'état WAITING.

concession du fil: méthode de rendement

Appelez la méthode de rendement fera le thread courant émit (release) CPU tranche de temps d'exécution, tranche en compétition à nouveau pour le temps CPU avec d'autres threads.

En général, les hauts sujets prioritaires sont plus susceptibles de concurrencer de tranches de temps CPU, mais ce n'est pas absolue, et certains ne sont pas sensibles à la priorité de thread OS.

Fil des interruptions: Méthode interrup

interrup méthode pour un fil d'émettre un avis de signal de fin, il aura une incidence sur un indicateur d'interruption interne du fil, le fil lui-même et ne sera pas appeler interrup état de changement de méthode. Spécifique change d'état d'attendre l'identification finale du résultat de l'exécution du programme d'interruption reçu est déterminée. La compréhension de la méthode de interrup doit prêter attention à accepter 4 points de base:

méthode d'appel interrup ne interruption d'un fil conducteur, fil qui est dans l'état en cours et ne sera pas interrompu et terminé seulement changé le maintien interne du drapeau d'interruption, rien de plus. Le code source du JDK de base:

/**
     * Tests whether the current thread has been interrupted.  The
     * <i>interrupted status</i> of the thread is cleared by this method.  In
     * other words, if this method were to be called twice in succession, the
     * second call would return false (unless the current thread were
     * interrupted again, after the first call had cleared its interrupted
     * status and before the second call had examined it).
     *
     * <p>A thread interruption ignored because a thread was not alive
     * at the time of the interrupt will be reflected by this method
     * returning false.
     *
     * @return  <code>true</code> if the current thread has been interrupted;
     *          <code>false</code> otherwise.
     * @see #isInterrupted()
     * @revised 6.0
     */
    public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }

    /**
     * Tests whether this thread has been interrupted.  The <i>interrupted
     * status</i> of the thread is unaffected by this method.
     *
     * <p>A thread interruption ignored because a thread was not alive
     * at the time of the interrupt will be reflected by this method
     * returning false.
     *
     * @return  <code>true</code> if this thread has been interrupted;
     *          <code>false</code> otherwise.
     * @see     #interrupted()
     * @revised 6.0
     */
    public boolean isInterrupted() {
        return isInterrupted(false);
    }

appel de méthode de sommeil Ruoyin le fil est dans un état minutées WAITING, appelant la méthode d'interruption jette InterruptedException, avant la fin du fil Etat minutées WAITING.
De nombreuses méthodes qui jettent InterruptedException, comme Thread.sleep (moulins longues), une exception est levée devant effacera le drapeau d'interruption, alors appelé après avoir jeté une exception méthode interrompue renvoie false.

Fil d'interruption état est inhérent à un drapeau, ce drapeau peut mettre fin au fil de sécurité. Par exemple, lorsque vous voulez mettre fin à un fil, vous pouvez appeler la méthode d'interruption de ce fil, puis la méthode d'exécution du thread renvoie la valeur d'état du fil de sécurité selon la méthode de mettre fin fil isInterrupted.

public class SafeInterruptThread extends Thread {
    @Override
    public  void run(){
        if(!Thread.currentThread().isInterrupted()){
            try {
                //☆此处处理正常的线程业务逻辑

                //sleep会抛出InterruptedException
                sleep(11);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); //重置中断标识
//                e.printStackTrace();
            }
        }
        if(Thread.currentThread().isInterrupted()){
            //☆处理线程结束前必要的一些资源释放和清理工作。比如释放锁。
            //存储数据到持久化层、发出异常通知等，用于実現线程的安全退出。
            try {
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//☆ 定义一个可安分退出的线程
SafeInterruptThread thread = new SafeInterruptThread();
//☆ 安全退出线程
thread.interrupt();

Enfilez ajouter: méthode join

méthode join pour attendre l'autre thread de mettre fin, si méthode join appelle un autre thread dans le thread courant, le fil courant dans l'état bloqué, jusqu'à la fin d'un autre fil, le fil courant est alors bloqué par l'état à l'état prêt, en attendant d'acquérir la CPU les droits d'utilisation. Dans de nombreux cas, le thread principal pour créer et démarrer un thread enfant a besoin d'attendre jusqu'à ce que le fil de l'enfant et retourner les résultats collectés et traités et puis quittez, alors nous devrions utiliser la méthode join. Des méthodes spécifiques sont les suivantes:

ChildrenThread childrenThread = new ChildrenThread();   //子线程开始运行
childrenThread.join();                                  //等待子线程childrenThread执行结束
//子线程join()结束,开始运行主线程

sillages de discussion: notifier la méthode

Objet classe a notify méthode pour réveiller une attente de fil sur l'écran de cet objet. Si tous les threads attendent sur cet objet sera sélectionné réveiller un fil. Le choix est arbitraire.

Nous appelons habituellement l'un des objets de la méthode d'attente sur le moniteur d'un objet d'attente jusqu'à ce que le verrou sur cet objet pour le thread courant d'abandonner, de continuer à être thread Eveillé, le fil sera réveillé dans une manière classique et synchronisée activement sur cet objet l'autre concours de fil.

Des méthodes similaires également notifyAll, utilisés pour réveiller tous les threads en attente sur le moniteur.

fil Daemon: setDaemon

setDaemon méthode pour définir un thread démon, aussi connu comme « fil de service », le fil est un fil d'arrière - plan, il a une fonction qui fournit un service public pour le thread utilisateur laissera automatiquement lorsque aucun thread réparable par l'utilisateur.

Tuteur fil de priorité inférieure, est utilisé pour fournir des services à d'autres objets et les fils dans le système. Établira un fil d'utilisateur en tant que méthode de thread démon est de créer un objet de fil avant que l'objet de fil setDaemon (true) à régler.

Fil défini dans le thread démon est thread démon. fil Daemon est le niveau JVM, tel que du fil GC est un fil typique de démon dans notre programme, il n'y a plus de fil en cours d'exécution, le programme ne produira pas les ordures, le garbage collector il n'y a rien à faire, alors sur la récupération des fils restants JVM, GC fil partira automatiquement. Il est toujours exécuté à un état de faible niveau, les ressources recyclables pour les systèmes de surveillance et de gestion en temps réel.

fil Daemon est un fil spécial en cours d'exécution en arrière-plan, indépendamment du terminal de commande et effectuer périodiquement une tâche ou en attente d'un événement a eu lieu. Ce thread démon ne dépend pas du terminal, mais dépend de la machine virtuelle Java, la machine virtuelle Java avec la mort totale. Lorsque tous les threads de la machine virtuelle Java sont threads démon, machine virtuelle Java peut quitter. S'il est thread non-démon, la machine virtuelle Java ne sera pas quitter.

Impact de chaque méthode de l'état de thread

La différence entre le sommeil et la méthode d'attente de la méthode

La méthode de la classe Thread appartient à dormir, et la méthode d'attente appartiennent à la classe Object

méthode de sommeil pour suspendre le temps spécifié, de sorte que la CPU aux autres threads, mais il reste à surveiller l'état, l'état reprend automatiquement son fonctionnement après une durée spécifiée.

Dans la méthode du sommeil des appels de procédure, le fil ne sera pas libérer le verrou de l'objet.

Lorsque vous appelez la méthode d'attente, le fil va abandonner le verrou d'objet, en attendant d'entrer dans la piscine en attendant la serrure pour cet objet, appeler uniquement pour cet objet informe la méthode, le pool de threads prêt à entrer dans l'acquisition de verrouillage d'objet le verrou d'objet, et entrez l'état de marche.

Démarrer, Exécuter

Méthode de démarrage pour démarrer le fil, Mika maintenant vraiment le fonctionnement multi-thread. Après avoir appelé le début, le fil exécutera en arrière-plan, sans attendre que le code du corps méthode d'exécution l'exécution est terminée, vous pouvez continuer avec le code suivant.
Lorsque vous commencez à appeler lancer un fil, le fil est dans l'état prêt et ne fonctionne pas.
Procédé terme, également connu sous le corps de fil. Après avoir appelé la course, le fil dans l'état de fonctionnement. Thread se termine après la course.

Terminate le fil des quatre façons

1. finitions en cours d'exécution normalement

exécution du thread corps est terminé.

2. Utilisez le fil de sortie du panneau de sortie

Dans des circonstances normales, lorsque la méthode d'exécution exécutée, le fil sera la fin normale. Cependant, un fil est un fil d'arrière-plan, vous devez exécuter depuis longtemps, rencontrer après que certaines conditions spécifiques dans le système, afin de déclencher un arrêt. Ensuite, vous pouvez utiliser une variable pour le contrôle et vrai ou faux pour le contrôler en réglant ce drapeau.

exemple:

public class ThreadSafe extends Thread {
    public volatile boolean exit = false;
    @Override
    public void run(){
        while (!exit){
            //业务逻辑代码
        }
    }
}

Le code ci - dessus définit un signe à cesser de sortie dans le fil, la valeur par défaut est fausse. Utilisé pour définir la sortie d'un mot - clé Java volatile , ce mot - clé est utilisé pour sortir de la synchronisation de fil de sécurité, ce qui signifie que dans le même temps , un seul fil peut modifier la sortie de valeur. Lorsque la sortie est vrai, alors que la sortie de boucle.

3. Utilisation de la méthode d'interruption se termine le filetage

Terminate le fil en utilisant la méthode d'interruption a les deux cas suivants:

1) Le fil est bloqué.

Par exemple, lors de l' utilisation d' un sommeil, appelez l'attente de verrouillage ou appelez la prise du récepteur, accepter d' autres méthodes pour faire le fil est bloqué . Lorsque vous appelez la méthode d' interruption throws Exception InterruptedException. Nous saisissons l'exception dans le code, puis sortir de l'état de détection de boucle, vous avez la possibilité de mettre fin à l'exécution de ce fil. Notez que non seulement appeler la méthode d'interrompre les extrémités de fil , il faut d' abord capturer anomalie InterruptedException puis sortir du cycle de la fin de la méthode de fonctionnement normal.

Implémentation spécifique:

public class ThreadSafe extends Thread {
    @Override
    public void run() {
        while (!isInterrupted()) {   //在非阻塞过程中通过判断中断标志来退出
            try {
                Thread.sleep(5 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;              //在捕获到异常后执行break跳出循环
            }
        }
    }
}

2) Etat de fil ne soit pas bloqué par le

Cette fois -ci en utilisant la méthode de détermination de l'indicateur d' interruption isInterrupted fil pour sortir de la boucle. Lors de l' appel méthode d' interruption, l'indicateur d' interruption est définie sur true, et le fil ne peut pas sortir immédiatement , mais l' opération de libération des ressources avant de fil se termine d'exécution, le fil est en attente de sortie après la sortie des ressources est terminée.

4. Utilisez la méthode d'arrêt pour mettre fin à des fils: dangereux

Dans le programme peut appeler la méthode directement Thread.stop forcée de mettre fin au fil, mais cela est très dangereux, pourrait avoir des conséquences imprévisibles.

Il est comme alimenté soudainement.

Lorsque le programme utilise la méthode Thread.stop pour terminer le fil, l'enfant Enfiler le fil lancera ThreadDeathError erreur et libérer tous les fils de l' enfant tenant le verrou . bloc de code verrouillé est généralement utilisé pour protéger la cohérence des données, si l'avance prise par le fil après avoir appelé la méthode Thread.stop libération soudaine toutes les serrures de sorte que la serrure ne peut pas contrôler les ressources, la protection des données peut apparaître en contradiction avec la situation.