源码版本:jdk8
其中的部分论证和示例代码:Java_Concurrency
类声明:
Thread本身实现了Runnable接口
Runnable:任务,《java编程思想》中表示该命名不好，或许叫Task更好；
Thread：线程，执行任务的载体；
public class Thread implements Runnable
**构造方法: **
构造时,可以指定线程组,线程运行任务Runnable对象,线程名和栈大小
线程的所有构造方法,都是通过init()实现
/**
* Thread的所有public构造方法传入的inheritThreadLocals均为true
* 只有一个权限为default的构造方法传入为false
* 所有的构造方法实现均是调用了该方法
*/
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
// 构造方法中传入的线程名不能为null
// 默认线程名:"Thread-" + nextThreadNum()
if (name == null) {
throw new NullPointerException("name cannot be null");
}
this.name = name;
// 被创建出来的线程是创建线程的子线程
Thread parent = currentThread();
// 新建线程的线程组
// 如果构造方法传入的线程组为null,则通过这个流程来决定其线程组,通常,新建线程的线程组为其创建线程的线程组
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属性
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 (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
/* Stash the specified stack size in case the VM cares */
this.stackSize = stackSize;
// 产生新的tid并设置
tid = nextThreadID();
}
public long getId() {
return tid;
}
上面的源码中有一个stackSize的参数,这个一般不会使用,其具体请参考javadoc.
默认线程名:"Thread-" + nextThreadNum():
/* For autonumbering anonymous threads. */
private static int threadInitNumber;
// 同步方法,保证tid的唯一性和连续性
private static synchronized int nextThreadNum() {
return threadInitNumber++;
}
// 线程名可以被修改
public final synchronized void setName(String name) {
checkAccess();
if (name == null) {
throw new NullPointerException("name cannot be null");
}
this.name = name;
if (threadStatus != 0) {
setNativeName(name);
}
}
public final String getName() {
return name;
}
ThreadGroup:
《java编程思想》有云：把ThreadGroup当做是一次不成功的尝试即可，不用理会
public final ThreadGroup getThreadGroup() {
return group;
}
Thread类默认的toString()中有使用其ThreadGroup:
public String toString() {
ThreadGroup group = getThreadGroup();
if (group != null) {
return "Thread[" + getName() + "," + getPriority() + "," + group.getName() + "]";
} else {
return "Thread[" + getName() + "," + getPriority() + "," + "" + "]";
}
}
守护线程:
具体参考:Java 守护线程概述
示例:Daemon.java
/**
* Marks this thread as either a {@linkplain #isDaemon daemon} thread
* or a user thread. The Java Virtual Machine exits when the only
* threads running are all daemon threads.
* <p> This method must be invoked before the thread is started.
*/
public final void setDaemon(boolean on) {
checkAccess();
// 只有在线程开始前设置才有效
if (isAlive()) {
throw new IllegalThreadStateException();
}
daemon = on;
}
public final boolean isDaemon() {
return daemon;
}
// 返回当前线程是否还活着
// start()后且还没有死亡的线程均视为活着的线程
public final native boolean isAlive();
线程优先级和线程状态：
构造时如果不指定,默认线程优先级就是NORM_PRIORITY
public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;
public final void setPriority(int newPriority) {
ThreadGroup g;
checkAccess();
// 优先级范围 1~10
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;
}
private native void setPriority0(int newPriority);
/**
* A thread state. A thread can be in one of the following states:
* NEW:A thread that has not yet started is in this state.
* RUNNABLE:A thread executing in the Java virtual machine is in this state.
* BLOCKED:A thread that is blocked waiting for a monitor lock is in this state.
* WAITING:A thread that is waiting indefinitely for another thread to
* perform a particular action is in this state.
* TIMED_WAITING:A thread that is waiting for another thread to perform an action
* for up to a specified waiting time is in this state.
* TERMINATED:A thread that has exited is in this state.
* A thread can be in only one state at a given point in time.
* These states are virtual machine states which do not reflect
* any operating system thread states.
* @since 1.5
*/
public enum State {
// 创建后,但是没有start(),调用了start()后,线程才算准备就绪,可以运行(RUNNABLE)
NEW,
// 正在运行或正在等待操作系统调度
RUNNABLE,
// 线程正在等待监视器锁
// 正在synchronized块/方法上等待获取锁,或者调用了Object.wait(),等待重新获得锁进入同步块
BLOCKED,
// 调用Object.wait(),Thread.join()或LockSupport.park()会进入该状态,注意这里的调用均为没有设置超时,
// 线程正在等待其他线程进行特定操作,比如,调用了Object.wait()的线程在另一个线程调用Object.notify()/Object.notifyAll()
// 调用了Thread.join()的线程在等待指定线程停止,join()的内部实现方式也是Object.wait(),只不过其Object就是线程对象本身
WAITING,
// 调用Thread.sleep(),Object.wait(long),Thread.join(long),
// LockSupport.parkNanos(long),LockSupport.parkUntil(long)会进入该状态,
// 注意,这里的调用均设置了超时
TIMED_WAITING,
// 线程执行完成,退出
TERMINATED;
}
// @since 1.5
public State getState() {
// get current thread state
return sun.misc.VM.toThreadState(threadStatus);
}
这里关于线程状态需要特别注意,在网上有很多博客和书籍对线程状态进行讲解,其中很大一部分是错误的,对于BLOCKED,WAITING和TIMED_WAITING有所误解,认为一个线程在被从Object.wait()中被唤醒时,会立即进入Runnable状态,其实不是的:
一个线程在被从Object.wait()中被唤醒时,会立即进入BLOCKED状态,这时其并没有获得锁,只是被唤醒了,再次开始对Object的监视器锁进行竞争;只有在其竞争获得锁之后才会进入RUNNABLE状态.
在理解java线程状态时,建议直接看Thread.State的注释,就看英文版本,最贴切,没有杂质,也最正确,其他的所有书上的讲解似乎都有些偏颇
线程状态示例:ThreadState.java
线程优先级示例:Priority.java
关于wait()/notify()具体相关,请参考其他相关博客;
run():
如果是构造Thread对象的时候,传入了该对象预期执行的任务----Runnable对象时,执行该任务,否则,什么都不做,当然,可以通过集成Thread类,重写run(),来修改其行为:
/* What will be run. */
private Runnable target;
@Override
public void run() {
if (target != null) {
target.run();
}
}
线程启动:
调用start()与调用run()的区别:懒得说
/* Java thread status for tools,
* initialized to indicate thread 'not yet started'
*/
private volatile int threadStatus = 0;
// 启动线程,JVM会调用当前Thread对象的run()
// 同步方法
public synchronized void start() {
// A zero status value corresponds to state "NEW".
// 如果调用时不是在线程状态不是NEW,则抛出IllegalThreadStateException
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()来实现线程启动
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();
线程打断:
/* The object in which this thread is blocked in an interruptible I/O
* operation, if any. The blocker's interrupt method should be invoked
* after setting this thread's interrupt status.
*/
private volatile Interruptible blocker;
private final Object blockerLock = new Object();
/* Set the blocker field; invoked via sun.misc.SharedSecrets from java.nio code
*/
void blockedOn(Interruptible b) {
synchronized (blockerLock) {
blocker = b;
}
}
/**
* 打断当前执行线程
* 如果当前线程阻塞在Object.wait(),Thread.join(),Thread.sleep()上,
* 那么该线程会收到InterruptedException,且线程的打断标志会被清除;
* 如果当前线程阻塞在InterruptibleChannel上,那么该InterruptibleChannel
* 会被关闭,线程的打断标志会被置位,且当前线程会收到ClosedByInterruptException;
* 如果当前线程阻塞在Selector上,那么该Selector的selection操作将会立即返回一个非0的结果,
* 且Selector.wakeup()会被调用,线程的打断标志会被置位,
* 如果上述情况均不存在,将当前线程的打断标志置位
* 打断一个isAlive()返回false的线程没有效果,isInterrupted()仍然会返回false;
*/
public void interrupt() {
if (this != Thread.currentThread())
checkAccess();
synchronized (blockerLock) {
Interruptible b = blocker;
// 在Interruptible上阻塞
if (b != null) {
interrupt0(); // Just to set the interrupt flag
b.interrupt(this);
return;
}
}
interrupt0();
}
private native void interrupt0();
/**
* 返回线程是否被打断(打断标志是否被置位)
* 传入的参数决定是否该方法是否会清除终端标志位
*/
private native boolean isInterrupted(boolean ClearInterrupted);
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}
public boolean isInterrupted() {
return isInterrupted(false);
}
关于isInterrupted()和interrupted()的区别,上述源码表现得很明显
而且,也体现了NIO的可中断中断实现方式
注意:interrupt()不能中断执行阻塞IO操作的线程.
线程的礼让—— yield() sleep() join():
关于Thread.sleep()和Object.wait()的区别:参考链接
示例:Yield.java
/**
* 暗示调度器让出当前线程的执行时间片,调度器可以选择忽略该暗示;
* 该方法在用来调试和测试时可能很有用,可以用来重现需要特殊条件才能复现的bug;
* 也可以用来进行并发优化等;
*/
public static native void yield();
/**
* 当前执行线程休眠指定毫秒在休眠期间,不释放任何当前线程持有的锁;
*/
public static native void sleep(long millis) throws InterruptedException;
/**
* 当前执行线程休眠指定毫秒在休眠期间,不释放任何当前线程持有的锁;
* 如果当前被打断(该方法调用前或该方法调用时),抛出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");
}
// 纳秒最后还是转换成了毫秒233333
// 可能是考虑都有些
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
sleep(millis);
}
/**
* 当前执行线程等待指定线程(也就是该调用发生的Thread对象)死后再继续执行;
* 可以设置超时,如果设置超时为0,则为不设置超时;
* 线程结束时(terminate),将会调用自身的notifyAll(),唤醒在该Thread对象上wait()的方法;
* 如果该线程被打断,该方法将抛出InterruptedException,并将打断标志位清除
*/
// 同步方法,同步当前Thread对象,所以才能在其内部调用wait()
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");
}
// 使用isAlive()和wait()的循环实现
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
public final synchronized void join(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++;
}
join(millis);
}
public final void join() throws InterruptedException {
join(0);
}
/**
* 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;
}
被遗弃的方法——suspend() resume() stop():
关于这些方法被遗弃的原因,具体参考:Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?
/**
* 挂起当前线程
* 弃用原因:容易导致死锁
*/
@Deprecated
public final void suspend() {
checkAccess();
suspend0();
}
/**
* 从suspend()中恢复线程运行
* 弃用原因:容易导致死锁
*/
@Deprecated
public final void resume() {
checkAccess();
resume0();
}
/**
* 强制线程停止执行;
* 通过抛出一个ThreadDeath的方式来停止线程;
* 废弃原因:stop()会师范所有已持有的锁的监视器,如果存在之前被这些监视器保护的对象处于一个不连续
* 的状态(inconsistent state),这些被损坏的对象将会对其他线程可见,出现不可预期的行为;
*/
@Deprecated
public final void stop() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
checkAccess();
if (this != Thread.currentThread()) {
security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);
}
}
// A zero status value corresponds to "NEW", it can't change to
// not-NEW because we hold the lock.
if (threadStatus != 0) {
resume(); // Wake up thread if it was suspended; no-op otherwise
}
// The VM can handle all thread states
stop0(new ThreadDeath());
}
ThreadLocal:
在Thread类中有两个与ThreadLocal相关的成员变量
具体有关ThreadLocal,请参考:
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
/*
* InheritableThreadLocal values pertaining to this thread. This map is
* maintained by the InheritableThreadLocal class.
*/
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
ClassLoader:
关于ClassLoader,我暂时知道的也不多,先知道这个,以后有机会专门研究一下ClassLoader:
/* The context ClassLoader for this thread */
private ClassLoader contextClassLoader;
/**
* 当前线程的ClassLoader,默认创建时是父线程的ClassLoader
* @return the context ClassLoader for this Thread, or {@code null}
* indicating the system class loader (or, failing that, the
* bootstrap class loader)
* @since 1.2
*/
@CallerSensitive
public ClassLoader getContextClassLoader() {
if (contextClassLoader == null)
return null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
ClassLoader.checkClassLoaderPermission(contextClassLoader,Reflection.getCallerClass());
}
return contextClassLoader;
}
/**
* @param cl
* the context ClassLoader for this Thread, or null indicating the
* system class loader (or, failing that, the bootstrap class loader)
* @since 1.2
*/
public void setContextClassLoader(ClassLoader cl) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("setContextClassLoader"));
}
contextClassLoader = cl;
}
线程栈轨迹:
// 特殊编程技巧
private static final StackTraceElement[] EMPTY_STACK_TRACE
= new StackTraceElement[0];
private native static StackTraceElement[][] dumpThreads(Thread[] threads);
private native static Thread[] getThreads();
// 打印当前线程的栈轨迹(StackTrace),通过新建一个异常的方式实现
// 注意:这是一个静态方法
public static void dumpStack() {
new Exception("Stack trace").printStackTrace();
}
/**
* 获得栈轨迹,返回的是一个数组
* 数组的第0个栈轨迹为最近调用的栈轨迹
* @since 1.5
*/
public StackTraceElement[] getStackTrace() {
if (this != Thread.currentThread()) {
// check for getStackTrace permission
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(SecurityConstants.GET_STACK_TRACE_PERMISSION);
}
// 不是活着的,返回的栈轨迹长度为0
if (!isAlive()) {
return EMPTY_STACK_TRACE;
}
StackTraceElement[][] stackTraceArray = dumpThreads(new Thread[] {this});
StackTraceElement[] stackTrace = stackTraceArray[0];
// a thread that was alive during the previous isAlive call may have
// since terminated, therefore not having a stacktrace.
if (stackTrace == null) {
// 这样就不会返回null,调用者也无需判断null了
stackTrace = EMPTY_STACK_TRACE;
}
return stackTrace;
} else {
// Don't need JVM help for current thread
return (new Exception()).getStackTrace();
}
}
/**
* 返回所有线程的栈轨迹
* @since 1.5
*/
public static Map<Thread, StackTraceElement[]> getAllStackTraces() {
// check for getStackTrace permission
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(
SecurityConstants.GET_STACK_TRACE_PERMISSION);
security.checkPermission(
SecurityConstants.MODIFY_THREADGROUP_PERMISSION);
}
// Get a snapshot of the list of all threads
Thread[] threads = getThreads();
StackTraceElement[][] traces = dumpThreads(threads);
Map<Thread, StackTraceElement[]> m = new HashMap<>(threads.length);
for (int i = 0; i < threads.length; i++) {
StackTraceElement[] stackTrace = traces[i];
if (stackTrace != null) {
m.put(threads[i], stackTrace);
}
// else terminated so we don't put it in the map
}
return m;
}
UncaughtExceptionHandler:
示例:UncaughtExceptionHandlerEx.java
// null unless explicitly set
private volatile UncaughtExceptionHandler uncaughtExceptionHandler;
// null unless explicitly set
private static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;
/**
* 设置UncaughtExceptionHandler,该设置对所有线程有效
* 如果自身没有设置,则交给其线程组的UncaughtExceptionHandler处理,如果再没有,
* 则交给默认的的UncaughtExceptionHandler处理,也即这里设置的UncaughtExceptionHandler处理
* 注意这里的设置不应该设置为线程的线程组,这样的设置会造成死循环
* @since 1.5
*/
public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("setDefaultUncaughtExceptionHandler"));
}
defaultUncaughtExceptionHandler = eh;
}
/**
* 返回默认的UncaughtExceptionHandler,该UncaughtExceptionHandler对所有线程有效
* 这是一个静态方法
* @since 1.5
*/
public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler(){
return defaultUncaughtExceptionHandler;
}
/**
* 返回该线程的UncaughtExceptionHandler,如果没有,返回该线程的线程组
* ThreadGroup本身实现了UncaughtExceptionHandler接口
* @since 1.5
*/
public UncaughtExceptionHandler getUncaughtExceptionHandler() {
return uncaughtExceptionHandler != null ?
uncaughtExceptionHandler : group;
}
/**
* 设置该线程的UncaughtExceptionHandler
*/
public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
checkAccess();
uncaughtExceptionHandler = eh;
}
/**
* uncaught exception 分发给UncaughtExceptionHandler
* 该方法被JVM调用
*/
private void dispatchUncaughtException(Throwable e) {
getUncaughtExceptionHandler().uncaughtException(this, e);
}
其他:
// 返回当前语句执行的线程
public static native Thread currentThread();
// 不能克隆线程
@Override
protected Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
/**
* 返回该线程是否持有指定对象的监视器锁
* @since 1.4
*/
public static native boolean holdsLock(Object obj);