java8类库简单了解（三）Runnable和Thread

1，Runnable接口源码如下：package java.lang;
/**
* @since JDK1.0
*/
@FunctionalInterface
public interface Runnable {
public abstract void run();
}以前没注意，这一看让笔者有点惊讶，极简爆了

2，Thread部分源码如下：package java.lang;
/**
* @since JDK1.0
*/
public
class Thread implements Runnable {
/* Make sure registerNatives is the first thing <clinit> does. */
private static native void registerNatives();
static {
registerNatives();
}

//volatile:禁制指令重排序（多线程方面相关），即在底层处理中保证先执行name[]
private volatile char name[];
private int priority;
private Thread threadQ;
private long eetop;

/**
* 线程可以拥有的最小优先级。
*/
public final static int MIN_PRIORITY = 1;

/**
* 分配给线程的默认优先级。
*/
public final static int NORM_PRIORITY = 5;

/**
* 线程可以拥有的最大优先级。
*/
public final static int MAX_PRIORITY = 10;

/**
* 返回对当前正在执行的线程对象的引用。
*/
public static native Thread currentThread();

/**
* 暂停当前线程的运行，yield（）方法只能让同优先级的线程有执行的机会。
*/
public static native void yield();

/**
* 使当前线程休眠指定时间，暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。
*/
public static native void sleep(long millis) throws InterruptedException;

public static void sleep(long millis, int nanos)
throws InterruptedException {
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}

if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}

if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}

sleep(millis);
}

/**
* 分配一个新的Thread对象
*/
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}

/**
target：运行对象
* target - 启动此线程时调用其run方法的对象。 如果null ，这个类run方法什么都不做。
*/
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}

/**
* group - 线程组。 如果是null并且有一个安全管理员，那么该组由SecurityManager.getThreadGroup()决定 。
如果没有安全管理员或SecurityManager.getThreadGroup()返回null ，该组将设置为当前线程的线程组。
*/
public Thread(ThreadGroup group, Runnable target) {
init(group, target, "Thread-" + nextThreadNum(), 0);
}

/**
* name - 新线程的名称
*/
public Thread(String name) {
init(null, null, name, 0);
}

public Thread(ThreadGroup group, String name) {
init(group, null, name, 0);
}

public Thread(Runnable target, String name) {
init(null, target, name, 0);
}

/**
* 分配一个新的Thread对象，使其具有target作为其运行对象，具有指定的name作为其名称，属于group引用的线程组。
*/
public Thread(ThreadGroup group, Runnable target, String name) {
init(group, target, name, 0);
}

/**
* 分配一个新的Thread对象，以便它具有target作为其运行对象，将指定的name正如其名，以及属于该线程组由称作group ，并具有指定的堆栈大小 。
* @since 1.4
*/
public Thread(ThreadGroup group, Runnable target, String name,
long stackSize) {
init(group, target, name, stackSize);
}

/**
* 当前线程开始执行
*/
public synchronized void start() {

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 native void start0();

/**
* 线程的运行代码
*/
@Override
public void run() {
if (target != null) {
target.run();
}
}

/**
* This method is called by the system to give a Thread
* a chance to clean up before it actually exits.
*/
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;
}

/**
* 测试当前线程是否中断。该方法可以清除线程的中断状态 。
true如果当前线程已被中断; false否则。
*/
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}

/**
* 测试当前线程是否中断。线程的中断状态不受此方法的影响。
true如果当前线程已被中断; false否则。
*/
public boolean isInterrupted() {
return isInterrupted(false);
}

/**
* 测试这个线程是否活着。
*/
public final native boolean isAlive();

/**
* 更改此线程的优先级。
*/
public final void setPriority(int newPriority) {
ThreadGroup g;
checkAccess();
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
throw new IllegalArgumentException();
}
if((g = getThreadGroup()) != null) {
if (newPriority > g.getMaxPriority()) {
newPriority = g.getMaxPriority();
}
setPriority0(priority = newPriority);
}
}

/**
* 得到此线程的优先级。
*/
public final int getPriority() {
return priority;
}

/**
* 将此线程的名称更改为等于参数 name 。
*/
public final synchronized void setName(String name) {
checkAccess();
this.name = name.toCharArray();
if (threadStatus != 0) {
setNativeName(name);
}
}

/**
* 返回此线程的名称。
*/
public final String getName() {
return new String(name, true);
}

/**
* 等待这个线程死亡的时间最多为millis毫秒。 0的超时意味着永远等待。
*/
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;
}
}
}

/**
* 等待最多millis毫秒加上这个线程死亡的nanos纳秒。
*/
public final synchronized void join(long millis, int nanos)
throws InterruptedException {

if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}

if (nanos < 0 || n
4000
anos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}

if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}

join(millis);
}

/**
* 等待这个线程死亡。
*/
public final void join() throws InterruptedException {
join(0);
}

/**
* 将此线程标记为 daemon线程或用户线程。on - 如果 true ，将此线程标记为守护线程
*/
public final void setDaemon(boolean on) {
checkAccess();
if (isAlive()) {
throw new IllegalThreadStateException();
}
daemon = on;
}

/**
* 测试这个线程是否是守护线程。
*/
public final boolean isDaemon() {
return daemon;
}

/**
* 确定当前正在运行的线程是否有权限修改此线程。
*/
public final void checkAccess() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkAccess(this);
}
}

/**
* 返回此线程的字符串表示，包括线程的名称，优先级和线程组。
*/
public String toString() {
ThreadGroup group = getThreadGroup();
if (group != null) {
return "Thread[" + getName() + "," + getPriority() + "," +
group.getName() + "]";
} else {
return "Thread[" + getName() + "," + getPriority() + "," +
"" + "]";
}
}

private static final RuntimePermission SUBCLASS_IMPLEMENTATION_PERMISSION =
new RuntimePermission("enableContextClassLoaderOverride");

/** cache of subclass security audit results */
/* Replace with ConcurrentReferenceHashMap when/if it appears in a future
* release */
private static class Caches {
/** cache of subclass security audit results */
static final ConcurrentMap<WeakClassKey,Boolean> subclassAudits =
new ConcurrentHashMap<>();

/** queue for WeakReferences to audited subclasses */
static final ReferenceQueue<Class<?>> subclassAuditsQueue =
new ReferenceQueue<>();
}

/**
* Verifies that this (possibly subclass) instance can be constructed
* without violating security constraints: the subclass must not override
* security-sensitive non-final methods, or else the
* "enableContextClassLoaderOverride" RuntimePermission is checked.
*/
private static boolean isCCLOverridden(Class<?> cl) {
if (cl == Thread.class)
return false;

processQueue(Caches.subclassAuditsQueue, Caches.subclassAudits);
WeakClassKey key = new WeakClassKey(cl, Caches.subclassAuditsQueue);
Boolean result = Caches.subclassAudits.get(key);
if (result == null) {
result = Boolean.valueOf(auditSubclass(cl));
Caches.subclassAudits.putIfAbsent(key, result);
}

return result.booleanValue();
}

/**
* 返回此线程的标识符。
* @since 1.5
*/
public long getId() {
return tid;
}

/**
* 返回此线程的状态。
* @since 1.5
*/
public State getState() {
// get current thread state
return sun.misc.VM.toThreadState(threadStatus);
}