概述
线程是程序中的一个执行线程。java虚拟机允许应用程序具有多个线程执行并发运行。
每个线程都有优先权。优先级较高的线程优先于优先级较低的线程执行。
每个线程可能或可能不被标记为守护进程。
当代码运行时一些线程创建一个新的Thread对象，新的线程的优先级最初设置等于
它的创建线程，当创建线程是一个守护线程，它也是守护线程
当一个java虚拟机启动时，通常有一个单一的非守护进程线程（通常调用名为某些指定类的main
java虚拟机器继续执行线程，直到以下任一个发生：
1、Runtime的exit方法以及被调用 并且安全管理器允许退出操作发生。
2、不是守护线程线程的所有线程都已死亡，从调用返回到run方法或通过抛出传播超出run方法的异常。
有两种方法来创建一个新的执行线程。
一是
将类声明为Thread的子类。这个
*子类应该重写类的Runnable方法
然后子类的实例可以是分配和启动。
例如，一个计算素数大于规定值的线程可写如下：
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();
*创建线程的另一种方法是声明一个类实现<代码> Runnaby<代码>接口。
*然后被分配，在创建时作为参数传递
那个类实现runnable方法。当创建并启动线程时，类的一个实例被分配，并作为参数传递
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();
*每个线程都有用于标识目的的名称。
不止一个线程可能具有相同的名称。如果未指定名称时创建一个线程，为它生成一个新名称。
*除非另有说明，将{@代码null }参数传递给构造函数。或该类中的方法将导致NullPointerException
方法
提示当前线程愿意让出 它当前处理的使用权。调度器可以忽略这个提示。
在线程之间让步是改善相对处理的启发式尝试，否则将过度利用CPU。其使用应结合详细的分析和基准测试确保它实际上具有预期的效果。
使用这种方法很少合适。也许可以用于调试或测试目的，在那里可能有助于重现由于竞争条件而出现的bug。在设计并发控制结构时也可能有用。例如{@link java.util.concurrent.locks} package
public static native void yield();在执行指定的毫秒数范围内，使当前正在执行的线程休眠（暂时停止），服从系统定时器和调度器的精度和准确性。线程不会失去任何监视器的所有权。
如果任何线程中断了当前线程。这个当前线程中断的状态将在抛出异常时清除。
public static native void sleep(long millis) throws InterruptedException;
用当前AccessControlContext初始化线程。
private void init(ThreadGroup g, Runnable target, String name,
long stackSize) {
init(g, target, name, stackSize, null);
}
初始化一个线程。
/ * @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;
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);
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 */
tid = nextThreadID();
}分配一个新的线程对象，
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}分配一个新的Thread对象，使其具有Target作为其运行对象，具有指定的name作为其名称，属于group引用的线程组。如果有一个安全管理器，{SecurityManager}检查访问（ThreadGroup）checkAccess }方法以线程组作为参数来调用。
另外，它的checkPermission()方法被调用带有
RuntimePermission(“enableContextClassLoaderOverride”权限
由重写getContextClassLoader或者setContextClassLoader的子类构造函数直接或间接调用
新创建的线程的优先级设置为等于创建线程的优先级，即当前运行的线程。该方法setPriority 可能是
用于将优先级更改为新值。
当且仅当创建线程的当前线程被标记作为守护进程线程时，新创建的线程最初被标记为守护线程，setDaemon可以用来改变线程是否是守护进程。
public Thread(ThreadGroup group, Runnable target, String name) {
init(group, target, name, 0);
}导致该线程开始执行的java虚拟机调用该线程的run方法。
结果是两个线程同时运行：当前线程（从调用返回到start方法）和另一个线程（执行它的run方法）
启动线程不止一次是不合法的，特别是，线程一旦完成执行，就不能重新启动。
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's list of threads
* and the group'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 void exit() {
if (group != null) {
group.threadTerminated(this);
group = null;
}
/* Aggressively null out all reference fields: see bug 4006245 */
target = null;
/* Speed the release of some of these resources */
threadLocals = null;
inheritableThreadLocals = null;
inheritedAccessControlContext = null;
blocker = null;
uncaughtExceptionHandler = null;
}
中断此线程
除非，通过调用线程checkAccess()对象 允许当前线程中断它自身，否则抛出SecurityException
如果线程在调用wait()方法、或者Object的等待方法或者join sleep方法时阻塞
它的中断状态将被清除或者抛出InterruptedException
如果线程阻塞在IO操作InterruptibleChannel
然后这个通道将被关闭，线程中断状态将被设置，线程将接收一个ClosedByInterruptException
如果线程阻塞在一个selector 然后这个线程的中断状态将被设置
或者他立即从select操作中返回，可能是以非零值，仅当Selector wakeup方法被调用
如果前面的条件没有一个，那么这个线程中断状态将被设置。
中断不是活着的线程不会产生任何效果
public void interrupt() {
if (this != Thread.currentThread())
checkAccess();
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
interrupt0(); // Just to set the interrupt flag
b.interrupt(this);
return;
}
}
interrupt0();
}测试当前线程是否已中断。这个
通过该方法清除线程的*中断状态。在换句话说，如果这种方法被连续调用两次，
第二次调用将返回false（除非当前线程又被中断，在他的第一次调用已经清楚它的中断状态 并且在第二次调用之前检查它
）。
一个线程中断将会被忽略 因为一个线程不在中断的时间存活 将被这个方法返回false反映
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}在该线程中最多等待millis毫秒死亡。0的超时意味着永远等待。
通过循环调用wait 基于isAlive方法
当一个线程终止，notifyAll方法将被调用
建议不要使用wait notify 或者notifyAll在线程实例
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
返回此线程的上下文类加载器。语境ClassLoader由线程的创建者提供使用。
在加载类和资源时，在该线程中运行代码。
如果不是setContextClassLoader 集合，则默认为父线程的类加载器上下文。这个上下文类加载器
原始线程通常被设置为用于加载应用程序。
@CallerSensitive
public ClassLoader getContextClassLoader() {
if (contextClassLoader == null)
return null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
ClassLoader.checkClassLoaderPermission(contextClassLoader,
Reflection.getCallerClass());
}
return contextClassLoader;
}