java 线程Thread 技术--线程创建源码解释

永远不要忘记最基础的东西，只有把最基础的知识打牢靠，才能够使你走的更远，我将从今天开始，进行线程知识的回顾，一些常用知识点，以及java1.5 引入的并发库，进行详细的讲解与总结

创建线程的目的是为了开启一条执行路径，去运行指定的代码；

java 对线程的创建java.lang包下，我们先看关于Thread 源码文档，看它对Thread 有什么解释呢？

* 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>
翻译：
　　线程是程序中的执行线程，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.
 翻译：
　　每一个线程都是有优先级的，线程高的优先级优于线程低的优先级，每一个线程可以或者不可以标记为一个守护线程
　当一个线程中运行创建了一个新的线程对象，这个新线程的优先级初始值等于创建它的线程的优先级，当创建线程是守护线程的
时，新线程才是守护程序

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

翻译：
　　当Java 虚拟机 启动的时候，通常都会有单个非守护线程（代表性的他会调用某个类的main 方法）Java 虚拟机会一直运行
知道下面的情况发生
　　1.使用了runtime 类的exit 方法，并且安全管理器允许退出操作发生
　　2.非守护线程中的线程停止运行，都会抛出传播到run方法之外的的异常

线程创建的两种方式：官方都有了明确的demo

* 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:
翻译：

声明一个继承Thread 的子类，这个子类应该去覆盖run 方法，这个子类的实例会被分配和启动；下面是例子：

 * <hr><blockquote><pre>
 *     class PrimeThread extends Thread {
 *         long minPrime;
 *         PrimeThread(long minPrime) {
 *             this.minPrime = minPrime;
 *         }
 *
 *         public void run() {
 *             // compute primes larger than minPrime
 *             &nbsp;.&nbsp;.&nbsp;.
 *         }
 *     }
 * </pre></blockquote><hr>
 * <p>
 * The following code would then create a thread and start it running:
 * <blockquote><pre>
 *     PrimeThread p = new PrimeThread(143);
 *     p.start();
 * </pre></blockquote>
 * <p>
 * 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:
翻译：
　　另一种方式是声明一个实现runnable 接口的类，然后实现run 方法，这个实例会被分配
在创建线程时候，它会被传递作为一个参数，然后start ，下面是例子

* <hr><blockquote><pre>
 *     class PrimeRun implements Runnable {
 *         long minPrime;
 *         PrimeRun(long minPrime) {
 *             this.minPrime = minPrime;
 *         }
 *
 *         public void run() {
 *             // compute primes larger than minPrime
 *             &nbsp;.&nbsp;.&nbsp;.
 *         }
 *     }
 * </pre></blockquote><hr>
 * <p>
 * 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>
 * <p>
 * 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.
 * <p>
 * Unless otherwise noted, passing a {@code null} argument to a constructor
 * or method in this class will cause a {@link NullPointerException} to be
 * thrown.

在下一节，我们对官方提供对两种方式进行实例编写