Thread类源码注释(1)

约定不等于承诺〃 2022-05-14 11:28 176阅读 0赞

备注：此文章适合新手入门

打开Thread源码，首先就是对Thread的说明

* A thread is a thread of execution in a program. The Java
 * Virtual Machine allows an application to have multiple threads of
 * execution running concurrently.

翻译：线程是程序中执行的线程。 Java虚拟机允许应用程序同时运行多个执行线程。  
自我感想：额。。。

* 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.

翻译：每个线程都有优先权。具有较高优先级的线程优先于优先级较低的线程执行。每个线程\*可能也可能不会被标记为守护进程。当在某个线程中运行的代码创建一个新的Thread对象时，新的线程的优先级最初设置为等于创建线程的优先级，并且当且仅当\*时才是守护程序线程创建线程是一个守护进程。  
自我感想：这里祥见：setDaemon()方法

* 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>

翻译：当Java虚拟机启动时，通常会有一个非守护程序线程（通常调用某个指定类的名为main的方法--这里指的是主线程）。 Java Virtual  Machine继续执行线程，  
    01.直到出现以下任一类Runtime 的 exit 方法已被\*调用并且 security manager 允许进行退出操作。   
    02.所有不是守护程序线程的线程都已经死亡，要么通过从run方法调用返回，要么抛出传播超出 run的异常方法。  
自我总结：这里如果在main方法中开启1个线程，则此时有2条线程在执行（一条主线程，一条普通线程），这里描述的是Thread的停止方式。

* 
 * 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 PrimeThread extends Thread {
 * long minPrime;
 * PrimeThread(long minPrime) {
 * this.minPrime = minPrime;
 * }
 *
 * public void run() {
 * // compute primes larger than minPrime
 *  . . .
 * }
 * }
 * </pre></blockquote><hr>
 * 
 * The following code would then create a thread and start it running:
 * <blockquote><pre>
 * PrimeThread p = new PrimeThread(143);
 * p.start();
 * </pre></blockquote>
 * 
 * The other way to create a thread is to declare a class that
 * implements the <code>Runnable</code> interface. That class then
 * implements the <code>run</code> method. An instance of the class can
 * then be allocated, passed as an argument when creating
 * <code>Thread</code>, and started. The same example in this other
 * style looks like the following:
 * <hr><blockquote><pre>
 * class PrimeRun implements Runnable {
 * long minPrime;
 * PrimeRun(long minPrime) {
 * this.minPrime = minPrime;
 * }
 *
 * public void run() {
 * // compute primes larger than minPrime
 *  . . .
 * }
 * }
 * </pre></blockquote><hr>
 * 
 * The following code would then create a thread and start it running:
 * <blockquote><pre>
 * PrimeRun p = new PrimeRun(143);
 * new Thread(p).start();
 * </pre></blockquote>
 * 
 * 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.

翻译：这里大致的意思就是讲怎么创建线程？一共有两种方式  
方式1 Demo：

class PrimeThread extends Thread {
             long minPrime;
              PrimeThread(long minPrime) {
                 this.minPrime = minPrime;
              }
     
              public void run() {
                 // compute primes larger than minPrime
          
              }
         }

那么如何调用呢？

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

总结下 创建线程的步骤：  
(1).定义类继承Thread  
(2).覆写Thread的run方法  
(3).执行类的start()方法--开启线程，执行run()方法

方式2 Demo：

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

调用方式如下：

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

总结步骤如下：
    （1）定义类实现Runnable接口
    （2）覆盖Runnable接口中的run方法
        将线程要运行的代码存放在run方法中
    （3）通过Thread类建立线程对象
    （4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
        为什么将Runnable接口的子类对象传递给Runnable接口的子类对象？
           因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去指定指定对象的run你方法，就必须明确该run方法所需对象
    （5）调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

后面我们具体会再贴出创建案例以及两个创建方式的区别。

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.

翻译：每个Thread都有一个用于识别目的的名称。超过一个线程可能具有相同的名称。如果在创建线程时未指定名称，则会为其生成新名称。

Unless otherwise noted, passing a {@code null} argument to a constructor * or method in this class will cause a {@link NullPointerException} to be * thrown

除非另有说明，否则将\{@code null\}参数传递给此类中的构造函数\*或方法将导致\*抛出\{@link NullPointerException\}。