本文出处Thread线程知识点讲解 转载请说明出处
内部属性
//线程名，如果创建时没有指定则使用Thread- + 创建序列号
private volatile String name;
//线程优先级 Java只是给操作系统一个优先级的参考值，线程最终在操作系统的优先级是多少还是由操作系统决定。
private int priority;
//守护线程
private boolean daemon = false;
//为JVM保留字段
private boolean stillborn = false;
private long eetop;
/* What will be run. */
private Runnable target;
//线程组，每一个线程必定存于一个线程组中，线程不能独立于线程组外
private ThreadGroup group;
// 类加载器，当线程需要加载类时，会使用内部类加器
private ClassLoader contextClassLoader;
/* For autonumbering anonymous threads. */
private static int threadInitNumber;
private static synchronized int nextThreadNum() {
return threadInitNumber++;
}
/* 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;
/*
* The requested stack size for this thread, or 0 if the creator did
* not specify a stack size. It is up to the VM to do whatever it
* likes with this number; some VMs will ignore it.
*/
private final long stackSize;
/*
* JVM-private state that persists after native thread termination.
*/
private long nativeParkEventPointer;
/*
* Thread ID
*/
private final long tid;
/* For generating thread ID */
private static long threadSeqNumber;
// 这个线程号是整个Thread 类共享的
private static synchronized long nextThreadID() {
return ++threadSeqNumber;
}
/*
* 线程状态
*/
private volatile int threadStatus;
复制代码构造函数
public Thread() {
this(null, null, "Thread-" + nextThreadNum(), 0);
}
public Thread(ThreadGroup group, Runnable target, String name,
long stackSize) {
this(group, target, name, stackSize, null, true);
}
private Thread(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
if (name == null) {
throw new NullPointerException("name cannot be null");
}
this.name = name;
Thread parent = currentThread(); //从创建Thread 的线程中获取到父线程
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 manager doesn't have a strong opinion
on 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(
SecurityConstants.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 (inheritThreadLocals && 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 */
this.tid = nextThreadID();
}
复制代码构造方法其实都是对Thread 内部属性进行初始化，比如线程名、优先级、类加器、线程Id。如果没有设置这些属性全部继承自当前的。让我比较奇怪是非常重要的threadStatus 没有赋值，而是使用了默认值，我猜想这个变量全程都是由c++来变更的，所以不必要使用Java进行赋值。 已经初始化的线程对象可以通过set方法去修改守护线程、线程名、优先级。
线程状态
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called {@code Object.wait()}
* on an object is waiting for another thread to call
* {@code Object.notify()} or {@code Object.notifyAll()} on
* that object. A thread that has called {@code Thread.join()}
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}
复制代码线程状态经常被问于面试中，几个状态和代表涵义大家都有记一记。
| 状态 | 描述 | 场景 |
|---|---|---|
| NEW | Thread线程刚刚被创建，创建状态 | new Thread |
| RUNNABLE | 运行状态，线程正在运行中 | Thread.start |
| BLOCKED | 堵塞状态 | synchronized 竞争失败 |
| WAITING | 等待，这种状态要么无限等待下去，要么被唤醒 | Object.wait、Lock |
| TIMED_WAITING | 等待超时，在等待时设置了时间，到时会自动唤醒 | Thread.sleep、LockSupport.parkNanos |
| TERMINATED | 死亡状态 | 线程已经执行完任务 |
从下图可以发现从创建-> 运行-> 死亡 这个过程是不可逆的。
线程运行和停止
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) //状态必须是创建状态 NEW ，防止一个对象多次调用start 方法
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); //加入线程组容器中，未开始线程数-1
boolean started = false;
try {
start0();
started = true;
} finally {
try {
// 进入到这里，则start0 创建一个线程失败了，要从线程组中删除它，未开始线程再加回来
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();
复制代码start方法比较简单的，先判断状态是否正确，在创建之前加入到线程组里面，失败了再移除。start0 方法应该就是调用系统资源真正去创建一个线程了，而且线程状态也是由这个方法修改的。
run方法只有使用Thread来创建线程，并且使用Runnable传参才会执行这里run方法，继承方式应该是直接调用子类run方法了。
public void run() {
if (target != null) { //有传入Runnable 对象，则调用该对象实现run方法
target.run();
}
}
复制代码stop方法虽然在Java2已经被官方停用了，很值得去了解下的。
@Deprecated(since="1.2")
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) { //不是NEW，线程已经运行了，如果被挂起了，需要对它进行唤醒
resume(); // Wake up thread if it was suspended; no-op otherwise
}
// The VM can handle all thread states
stop0(new ThreadDeath()); //停止线程，并且抛出一个异常给JVM
}
private native void stop0(Object o);
复制代码看完这个方法，也没有看出来stop()能干什么，我也不是很清楚这个stop能干什么，我将写几个例子验证功能。 创建几个线程去执行下任务，执行一会后，对所有线程调用stop方法，是否会退出任务。
public class ThreadStopTest {
public static void main(String[] args) {
ThreadStopTest t = new ThreadStopTest();
Runnable r = () -> {
int i = 0;
while (i < 1000){
t.spinMills(500);
System.out.println(Thread.currentThread().getName() + " : " + i);
i++;
}
};
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
Thread t3 = new Thread(r);
t1.start();
t2.start();
t3.start();
t.spinMills(2000);
t1.stop();
t2.stop();
t3.stop();
}
public void spinMills(long millisecond){
long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start < millisecond){
//自旋 ，模拟执行任务
}
}
}
复制代码执行结果
Thread-1 : 0
Thread-0 : 0
Thread-2 : 0
Thread-1 : 1
Thread-0 : 1
Thread-2 : 1
Thread-2 : 2
Thread-1 : 2
Thread-0 : 2
复制代码调用完stop方法，线程立刻退出任务，连一个异常都没有抛出的，真的是非常干脆。如果有人不下心使用stop方法，出现问题都非常难排除，所以Java 官方早早就停止使用它了，详细看官方说明
如果想优雅停止一个正在运行的线程，官方建议使用interrupted()。线程中断就是目标线程发送一个中断信号，能够收到中断信号线程自己实现退出逻辑。简单点说就是线程A在干活，突然有个人对它做了一个动作，线程A在知道这个动作涵义，它会知道自己要停下来。说白这就一个动作，如果线程逻辑没有处理这个动作代码，线程并不会退出的。看下Thread类里面有那些方法。
| 方法 | 备注 |
|---|---|
| interrupt() | 中断目标线程，给目标线程发一个中断信号，线程被打上中断标记 |
| isInterrupted() | 判断目标线程是否被中断，不会清除中断标记 |
| interrupted | 判断目标线程是否被中断，会清除中断标记 |
实现一个简单例子
public static void main(String[] args) throws InterruptedException {
Runnable r = () -> {
while (!Thread.currentThread().isInterrupted()){
//do some
System.out.println(System.currentTimeMillis());
}
System.out.println("线程准备退出啦");
Thread.interrupted();
};
Thread t = new Thread(r);
t.start();
Thread.sleep(1000);
t.interrupt();
}
复制代码上面代码核心是中断状态，如果中断被清除了，那程序不会跳出while循环的，下面改一下，添加一个sleep方法
public static void main(String[] args) throws InterruptedException {
Runnable r = () -> {
while (!Thread.currentThread().isInterrupted()){
//do some
try {
Thread.sleep(400);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(System.currentTimeMillis());
}
System.out.println("线程准备退出啦");
Thread.interrupted();
};
Thread t = new Thread(r);
t.start();
Thread.sleep(1000);
t.interrupt();
}
复制代码执行结果 ： 发送中断后，Thread.sleep直接抛出一个异常，并不会跳出循环。 因为sleep会响应中断，抛出一个中断异常，再清除线程中断状态。再回到while 判断时，中断状态已经被清除了，继续循环下去。 sleep()是一个静态native 方法，使当前执行的线程休眠指定时间，但是休眠的线程不会放弃监控器的锁（synchronized）,当任何线程要中断当前线程时，会抛出InterruptedException异常，并且清理当前线程的中断状态。所以在方法调用上就会抛出这个异常，让调用者去处理中断异常。
join和yield方法
join()就是一个等待方法，等待当前线程任务执行后，再次唤醒被调用的线程，常常用来控制多线程任务执行顺序。
/**
* Waits at most {@code millis} milliseconds for this thread to
* die. A timeout of {@code 0} means to wait forever.
*
* <p> This implementation uses a loop of {@code this.wait} calls
* conditioned on {@code this.isAlive}. As a thread terminates the
* {@code this.notifyAll} method is invoked. It is recommended that
* applications not use {@code wait}, {@code notify}, or
* {@code notifyAll} on {@code Thread} instances.
*
* @param millis
* the time to wait in milliseconds
*
* @throws IllegalArgumentException
* if the value of {@code millis} is negative
*
* @throws InterruptedException
* if any thread has interrupted the current thread. The
* <i>interrupted status</i> of the current thread is
* cleared when this exception is thrown.
*/
public final synchronized void join(final long millis)
throws InterruptedException {
if (millis > 0) {
if (isAlive()) { //这里获取线程状态，只是不是开始和死亡就算alive了
final long startTime = System.nanoTime();
long delay = millis;
do {
wait(delay);
} while (isAlive() && (delay = millis -
TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)) > 0); //在指定时间内沉睡
}
} else if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
throw new IllegalArgumentException("timeout value is negative");
}
}
复制代码想了解方法主要看方法注释就行，在指定时间内等待被调用者的线程死亡，如果没有死亡时间到了会自行唤醒，如果时间为0则永远等待下去，直到执行线程执行完任务。唤醒是由notifyAll执行的，但是没看见在哪里执行这个方法。查了一下资料知道每个线程执行完成后都会调用exit()方法，在exit会调用notifyAll。 yield(): 单词翻译过来就是让步的意思。主要作用当线程获取到执行权时，调用这个方法会主动让出执行器，它跟上面wait、sleep 不同，线程状态是没有改变的，此时任然是RUN。比如一个线程获取锁失败了，这时线程什么不能干，获取锁本身是很快，此时将线程挂起了，有点得不偿失，不如此时让出CPU执行器，让其他线程去执行。既不会浪费CPU宝贵时间，也不需要太耗费性能。这个方法经常用于java.util.concurrent.locks包下同步方法，看过并发工具类的同学应该都认识它。
线程间协作
wait方法让当前线程进入等待状态(WAITING)，并且释放监控锁，只有当其他线程调用notify或者notifyAll才会唤醒线程。 notify唤醒一个在等待状态的线程，重新进入RUNNABLE状态。 notifyAll唤醒所有正在等待状态的线程，重新进入RUNNABLE状态。 上面三个方法都必须在监控锁（synchronized)下使用，不然会抛出IllegalMonitorStateException。 wait、notify 两个方法结合就可以实现线程之间协作。比如最经典的生产者-消费者模型： 当上游消费者发送发送信息太多，导致队列挤压已经满了，这时消费者这边可以使用wait,让生产者停下里，当消费者已经开始消费了，此时队列已经被消费走一个信息了，有空间了，消费者可以调用notify，让上游生产者继续运作起来。当队列里面信息已经被消费完时，消费者会调用wait，让线程进入等待中，当上游线程有信息发送到队列时，此时队列中信息就不是全空的了，就可以调用wait 唤醒一个等待消费者。这样就可以形成线程之间相互通信的效果了。 简单实现消费者-生产者模型
public void push(T t){
synchronized (lock){
size++;
if (size == QUEUE_CAPACTIY) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
lock.notify();
//入队列中
}
}
public T poll(){
synchronized (lock){
size--;
if (size == 0) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
lock.notify();
return T;
}
}
复制代码Callable和 Thread关系
我们知道了所有的线程其实都是Thread.start去创建的，重写run 方法达到异常执行任务，但是Callable这个接口是否也是使用Thread或者Runnable接口，主要看FutureTask就知道如何实现了。 看下run方法
public void run() {
//如果线程已经被创建了，则不需要再次执行任务了
if (state != NEW ||
!RUNNER.compareAndSet(this, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable; //callable 方法实现类
if (c != null && state == NEW) { //刚刚初始化的状态
V result;
boolean ran;
try {
result = c.call(); //执行任务
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex); //保存异常,将等待队列的线程全部唤醒过来
}
if (ran)
set(result); //保存执行结果，将等待队列的线程全部唤醒过来
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
复制代码可以看出Callable仍然是使用Thread来创建线程的，内部通过维护state来判断任务状态，在run 方法中执行call方法，保存异常和执行结果。 看下get() 如何获取执行结果的吧
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING) //还在执行中
s = awaitDone(false, 0L); //等待任务执行完成或者中断，会堵塞调用线程
return report(s);
}
/**
* Awaits completion or aborts on interrupt or timeout.
*
* @param timed true if use timed waits
* @param nanos time to wait, if timed
* @return state upon completion or at timeout
*/
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
// The code below is very delicate, to achieve these goals:
// - call nanoTime exactly once for each call to park
// - if nanos <= 0L, return promptly without allocation or nanoTime
// - if nanos == Long.MIN_VALUE, don't underflow
// - if nanos == Long.MAX_VALUE, and nanoTime is non-monotonic
// and we suffer a spurious wakeup, we will do no worse than
// to park-spin for a while
long startTime = 0L; // Special value 0L means not yet parked
WaitNode q = null;
boolean queued = false;
for (;;) {
int s = state;
if (s > COMPLETING) { //如果状态已经有执行中变成其他 ，直接将状态返回
if (q != null)
q.thread = null;
return s;
}
else if (s == COMPLETING) //正在执行中，让出CPU执行权，而不是变换线程状态
// We may have already promised (via isDone) that we are done
// so never return empty-handed or throw InterruptedException
Thread.yield();
else if (Thread.interrupted()) { //处理线程中断，退出自旋
removeWaiter(q); //删除队列中的线程
throw new InterruptedException();
}
else if (q == null) {
if (timed && nanos <= 0L)
return s;
q = new WaitNode();
}
else if (!queued) //将等待结果线程放入一个队列中，其实这个队列就是来处理等待结果线程的中断的
queued = WAITERS.weakCompareAndSet(this, q.next = waiters, q);
else if (timed) {
final long parkNanos;
if (startTime == 0L) { // first time
startTime = System.nanoTime();
if (startTime == 0L)
startTime = 1L;
parkNanos = nanos;
} else {
long elapsed = System.nanoTime() - startTime;
if (elapsed >= nanos) {
removeWaiter(q);
return state;
}
parkNanos = nanos - elapsed;
}
// nanoTime may be slow; recheck before parking
if (state < COMPLETING) //任务没有启动，挂起等待线程
LockSupport.parkNanos(this, parkNanos);
}
else
LockSupport.park(this); //任务没有开始，挂起调用者，任务完成后会将它唤醒的
}
}
复制代码现在基本就明了，使用run 调用call方法，将执行结果保存起来，然后get 方法这边使用自旋方法等待执行结果，并且使用队列将等待的线程保存起来，来处理线程的唤醒、中断。
总结
这里简单说了Thread的构造方法，属性设置，比较重要就是线程几个状态，状态流转、线程启动停止，中断处理,几个常用方法的介绍。简单说了下FutureTask实现原理,结合上面提到的知识点，上面提到这些知识都是挺重要的，你可以看到大部分Java并发类都用到这些知识来开发的，频繁出现在面试中也是可以理解的。