L'utilisation de threads de concurrence Java et la création de threads de démarrage

Création de threads

Description du thread

• Les threads sont des threads d'exécution dans le programme. La machine virtuelle Java permet la simultanéité des applications. Exécutez plusieurs threads.

• Chaque thread a une priorité et l'exécution des threads de haute priorité a priorité sur les threads de faible priorité. Chaque thread peut ou non être marqué comme démon. Lorsque le code exécuté dans un thread crée un nouvel objet Thread, la priorité initiale du nouveau thread est définie sur la priorité du thread de création, et le nouveau thread est un démon si et seulement si le thread de création est un thread démon.

• Lorsque la machine virtuelle Java démarre, il existe généralement un seul thread non démon (il appelle généralement la méthode principale d'une classe spécifiée). La machine virtuelle Java continue d'exécuter le thread jusqu'à ce que l'une des conditions suivantes se produise :
  ​​​​​ 1. La méthode de sortie de la classe Runtime est appelée et le gestionnaire de sécurité autorise l'opération de sortie.
  ​​​​​2. Tous les threads qui ne sont pas des threads démons ont arrêté de s'exécuter, soit en revenant d'un appel à la méthode run, soit en levant une exception qui se propage en dehors de la méthode run.

• La manière d'implémenter les threads sera présentée dans les chapitres suivants

La référence du code source est la suivante :

/**
 * A <i>thread</i> is a thread of execution in a program. The Java
 * Virtual Machine allows an application to have multiple threads of
 * execution running concurrently.
 * <p>
 * Every thread has a priority. Threads with higher priority are
 * executed in preference to threads with lower priority. Each thread
 * may or may not also be marked as a daemon. When code running in
 * some thread creates a new <code>Thread</code> object, the new
 * thread has its priority initially set equal to the priority of the
 * creating thread, and is a daemon thread if and only if the
 * creating thread is a daemon.
 * <p>
 * When a Java Virtual Machine starts up, there is usually a single
 * non-daemon thread (which typically calls the method named
 * <code>main</code> of some designated class). The Java Virtual
 * Machine continues to execute threads until either of the following
 * occurs:
 * <ul>
 * <li>The <code>exit</code> method of class <code>Runtime</code> has been
 *     called and the security manager has permitted the exit operation
 *     to take place.
 * <li>All threads that are not daemon threads have died, either by
 *     returning from the call to the <code>run</code> method or by
 *     throwing an exception that propagates beyond the <code>run</code>
 *     method.
 * </ul>
 * <p>
 * There are two ways to create a new thread of execution. One is to
 * declare a class to be a subclass of <code>Thread</code>. This
 * subclass should override the <code>run</code> method of class
 * <code>Thread</code>. An instance of the subclass can then be
 * allocated and started. For example, a thread that computes primes
 * larger than a stated value could be written as follows:
 * <hr><blockquote><pre class="brush:php;toolbar:false">
 *     class PrimeThread extends Thread {
 *         long minPrime;
 *         PrimeThread(long minPrime) {
 *             this.minPrime = minPrime;
 *         }
 *
 *         public void run() {
 *             // compute primes larger than minPrime
 *              . . .
 *         }
 *     }
 * 

---

 * 

 * The following code would then create a thread and start it running:  * 

 *     PrimeThread p = new PrimeThread(143);
 *     p.start();
 * 

 * 

 * The other way to create a thread is to declare a class that  * implements the Runnable interface. That class then  * implements the run method. An instance of the class can  * then be allocated, passed as an argument when creating  * Thread, and started. The same example in this other  * style looks like the following:  * 

---

 *     class PrimeRun implements Runnable {
 *         long minPrime;
 *         PrimeRun(long minPrime) {
 *             this.minPrime = minPrime;
 *         }
 *
 *         public void run() {
 *             // compute primes larger than minPrime
 *              . . .
 *         }
 *     }
 * 

---

 * 

 * The following code would then create a thread and start it running:  * 

 *     PrimeRun p = new PrimeRun(143);
 *     new Thread(p).start();
 * 

 * 

 * Every thread has a name for identification purposes. More than  * one thread may have the same name. If a name is not specified when  * a thread is created, a new name is generated for it.  * 

 * Unless otherwise noted, passing a {@code null} argument to a constructor  * or method in this class will cause a {@link NullPointerException} to be  * thrown.  *  * @author  unascribed  * @see     Runnable  * @see     Runtime#exit(int)  * @see     #run()  * @see     #stop()  * @since   JDK1.0  */ publicclass Thread implements Runnable {

Informations requises

Avant d'exécuter un thread, vous devez d'abord construire un objet thread. Lors de la construction de l'objet thread, vous devez fournir les attributs requis par le thread, tels que le groupe de threads auquel le fil appartient, la priorité du fil et s'il s'agit d'un démon et d'autres informations. Dans le nouveau Thread, la méthode suivante sera appelée pour instancier l’objet Thread.
Le code d'initialisation est le suivant :

    /**
     * Initializes a Thread.
     *
     * @param g the Thread group
     * @param target the object whose run() method gets called
     * @param name the name of the new Thread
     * @param stackSize the desired stack size for the new thread, or
     *        zero to indicate that this parameter is to be ignored.
     * @param acc the AccessControlContext to inherit, or
     *            AccessController.getContext() if null
     */
    private void init(ThreadGroup g, Runnable target, String name,                      
    long stackSize, AccessControlContext acc) {        
    if (name == null) {            
    throw new NullPointerException("name cannot be null");
        }        
        this.name = name;        //当前线程作为该线程的父线程
        Thread parent = currentThread();
        SecurityManager security = System.getSecurityManager();        //线程组的获取：如果传入的参数为空首先获取系统默认的安全组，如果为空获取父线程的安全组
        if (g == null) {            
        /* Determine if it's an applet or not */

            /* If there is a security manager, ask the security manager
               what to do. */
            if (security != null) {
                g = security.getThreadGroup();
            }            /* If the security doesn't have a strong opinion of the matter
               use the parent thread group. */
            if (g == null) {
                g = parent.getThreadGroup();
            }
        }        /* checkAccess regardless of whether or not threadgroup is
           explicitly passed in. */
        g.checkAccess();        /*
         * Do we have the required permissions?
         */
        if (security != null) {            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }

        g.addUnstarted();        
        this.group = g;        //设置daemon 、priority 属性为父线程对应的值
        this.daemon = parent.isDaemon();        
        this.priority = parent.getPriority();        
        
        if (security == null || isCCLOverridden(parent.getClass()))            
        this.contextClassLoader = parent.getContextClassLoader();        
        else
            this.contextClassLoader = parent.contextClassLoader;        
            this.inheritedAccessControlContext =
                acc != null ? acc : AccessController.getContext();        
                this.target = target;
        setPriority(priority);        //将父线程的InheritableThreadLocal复制过来
        if (parent.inheritableThreadLocals != null)            
        this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);        
                /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;        /* Set thread ID */ 
        //生成线程id（一个long型的字段threadSeqNumber）
        tid = nextThreadID();
    }

Conclusion

Un objet Thread nouvellement construit (new Thread()) se voit allouer de l'espace par son thread parent (thread actuel), et Le thread enfant hérite du Daemon, de la priorité et du contextClassLoader du thread parent pour le chargement des ressources, ainsi que du ThreadLocal héritable. En même temps, un identifiant de thread est attribué au thread enfant. Un objet thread exécutable termine son travail d'initialisation et attend d'être exécuté dans la mémoire tas.

Comment créer

Hériter un fil de discussion

Code

//方法1通过继承Thread实现class MyThread extends Thread{

    //需要实现的方法，该方法执行具体的业务逻辑
    @Override    public void run() {
        System.out.println(Thread.currentThread().getName()
                +" @@@@ MyThread。run（）我是通过继承Thread实现的多线程");
    }

}

Description

Trouvé via la découverte du code source du fil (le fil implémente Runnable ) Thread est en fait une instance qui implémente l'interface exécutable, qui représente une instance d'un thread, et la seule façon de démarrer un thread est via la méthode d'instance start() de la classe Thread . La méthode start() est une méthode native qui démarrera un nouveau thread et exécutera la méthode run(). Il est très simple d'implémenter le multithreading de cette manière. En étendant directement Thread via votre propre classe et en remplaçant la méthode run(), vous pouvez démarrer un nouveau thread et exécuter votre propre méthode run() définie.

Le corps de la méthode run() représente la tâche que le thread doit accomplir, qui est appelée

corps d'exécution du thread . Lorsque cet objet de classe de thread est créé, un nouveau thread est créé et entre dans le nouvel état de thread. En appelant la méthode start() référencée par l'objet thread, le thread entre dans l'état prêt. À ce stade, le thread peut ne pas être exécuté immédiatement, en fonction du timing de planification du processeur.

Implémenter l'interface Runnable

Code

//方法2通过实现runnable接口
//实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，
//并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。class MyRunnable implements Runnable{

    @Override    public void run() {
        System.out.println(Thread.currentThread().getName()+                
        " @@@@ MyRunnable。run（）我是通过实现Runnable接口实现的多线程");
    }

}

Utiliser Callable et Future pour implémenter le multi-threading avec les résultats renvoyés

Utiliser les interfaces Callable et Future pour créer fils. Plus précisément, créez une classe d’implémentation de l’interface Callable et implémentez la méthode clam(). Et utilisez la classe FutureTask pour envelopper l'objet de la classe d'implémentation Callable et utilisez cet objet FutureTask comme cible de l'objet Thread pour créer un thread.

Les tâches qui peuvent renvoyer une valeur doivent implémenter l'interface Callable. De même, les tâches sans valeur de retour doivent implémenter l'interface Runnable. Après avoir exécuté la tâche Callable, vous pouvez obtenir un objet Future. Appelez get sur l'objet pour obtenir l'objet renvoyé par la tâche Callable
Combiné avec l'interface de pool de threads ExecutorService, vous pouvez implémenter le légendaire multi-thread avec les résultats renvoyés. (L'utilisation d'Executor sera présentée en détail dans les articles suivants.).

//方法3通过Executor框架实现class MyCallable implements Callable<Integer>{
    //需要实现call方法而不是run方法
    @Override    public Integer call() throws Exception {        return 100;
    }
}

Démarrer le fil

Selon l'analyse du code source :

• 1. Une fois l'initialisation de l'objet terminée, exécutez le démarrage. Exécutez ce thread et la machine virtuelle Java appelle la méthode run du thread pour exécuter la logique métier du thread

• 2. sera deux threads s'exécutant en même temps : le thread actuel (le thread parent [informe de manière synchrone la machine virtuelle Java que tant que le planificateur de threads est inactif, le thread appelant la méthode start doit être démarré immédiatement], revenant au début méthode de l’appel) et un autre thread (exécutant sa méthode run).

• 3. Et il est illégal de démarrer un fil de discussion plusieurs fois. Surtout lorsqu'un thread a fini de s'exécuter, il ne peut pas être redémarré.
  La description du code source de la méthode de démarrage est la suivante :

   /**
     * Causes this thread to begin execution; the Java Virtual Machine
     * calls the <code>run</code> method of this thread.
     * <p>
     * The result is that two threads are running concurrently: the
     * current thread (which returns from the call to the
     * <code>start</code> method) and the other thread (which executes its
     * <code>run</code> method).
     * <p>
     * It is never legal to start a thread more than once.
     * In particular, a thread may not be restarted once it has completed
     * execution.
     *
     * @exception  IllegalThreadStateException  if the thread was already
     *               started.
     * @see        #run()
     * @see        #stop()
     */
    public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group&#39;s list of threads
         * and the group&#39;s unstarted count can be decremented. */
        group.add(this);        boolean started = false;        try {
            start0();
            started = true;
        } finally {            try {                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

参考代码

public class TestCreateThread {    public static void main(String[] args) {
        Thread myThread = new MyThread();
        myThread.setName("myThread");
        myThread.start();

        Runnable myRunnable = new MyRunnable();
        Thread myRunnableThread = new Thread(myRunnable);
        myRunnableThread.setName("myRunnableThread");
        myRunnableThread.start();

        Thread myRunnableThread2 = new MyThread(myRunnable);
        myRunnableThread2.setName("myRunnableThread2");
        myRunnableThread2.start();        //执行结果参考如下：
        //myThread @@@@ MyThread。run（）我是通过继承Thread实现的多线程
        //myRunnableThread2 @@@@ MyThread。run（）我是通过继承Thread实现的多线程
        //myRunnableThread @@@@ MyRunnable。run（）我是通过实现Runnable接口实现的多线程

        //测试callable方法
        // 创建MyCallable对象
        Callable<Integer> myCallable = new MyCallable();    
        //使用FutureTask来包装MyCallable对象
        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); 
        //FutureTask对象作为Thread对象的target创建新的线程
        Thread thread = new Thread(ft);
        thread.start();//启用

        //获取信息
        try {            //取得新创建的新线程中的call()方法返回的结果
            //当子线程此方法还未执行完毕，ft.get()方法会一直阻塞，
            //直到call()方法执行完毕才能取到返回值。
            int sum = ft.get();
            System.out.println("sum = " + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }        //使用ExecutorService处理多线程
        ExecutorService pool = Executors.newFixedThreadPool(10);  
        Future<Integer> f = pool.submit(myCallable);  
        // 关闭线程池  
        pool.shutdown(); 
        try {            int sum1 = f.get();
            System.out.println("sum1 = " + sum1);
        } catch (InterruptedException e) {            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

启动线程的注意事项

      无论何种方式，启动一个线程，就要给它一个名字！这对排错诊断系统监控有帮助。否则诊断问题时，无法直观知道某个线程的用途。

Thread与Runnable的关系

实现关系

Thread实现接口Runnable，并且实现了run方法，代码参考如下:

        //如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；
        //否则，该方法不执行任何操作并返回。
        //Thread 的子类应该重写该方法。
        /**
         * If this thread was constructed using a separate
         * <code>Runnable</code> run object, then that
         * <code>Runnable</code> object&#39;s <code>run</code> method is called;
         * otherwise, this method does nothing and returns.
         * <p>
         * Subclasses of <code>Thread</code> should override this method.
         *
         * @see     #start()
         * @see     #stop()
         * @see     #Thread(ThreadGroup, Runnable, String)
         */
        @Override
        public void run() {            if (target != null) {
                target.run();
            }
        }

}

区别

      当执行到Thread类中的run()方法时，会首先判断target是否存在，存在则执行target中的run()方法，也就是实现了Runnable接口并重写了run()方法的类中的run()方法。当时如果该Runnable的子类是通过一个继承Thread的子类（该且重写了run方法），则真正执行的是Thread子类重写的run方法（由于多态的原因）。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!