Thread类的常用方法

• String getName()　　返回该线程的名称。
• void setName(String name)　　改变线程名称，使之与参数 name 相同。
• int getPriority() 　　返回线程的优先级。
• void setPriority(int newPriority) 　　更改线程的优先级。
• boolean isDaemon() 　　测试该线程是否为守护线程。
• void setDaemon(boolean on)　　将该线程标记为守护线程或用户线程。
• static void sleep(long millis)
• void interrupt()　　中断线程。
• static void yield()　　暂停当前正在执行的线程对象，并执行其他线程。
• void join()　　等待该线程终止。
• void run()
• void start() 启动一个线程
• 从Object类继承来的方法　　void notify() void wait()

重点介绍的几个方法

join()方法的使用

阻塞当前线程，让调用此方法的线程先执行，当调用此方法的线程执行完了，再执行当前线程
如主线程执行线程A（threadA）的join方法，threadA.join(),此时会先执行线程A，主线程阻塞，知道线程A执行完毕。此方法只会阻塞主线程，不会阻塞其他线程，如同时有线程B(threadB)在执行。那这时是线程A和线程B同时执行。
我们来深入源码了解一下join()：

//Thread类中
public final void join() throws InterruptedException {
    join(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;
        }
    }
}

我们重点关注一下这两句，无限期等待的情况

while (isAlive()) {
    wait(0);    //wait操作，那必然有synchronized与之对应
}

注意这个wait()方法是Object类中的方法
大家都知道，有了wait()，必然有notify()，什么时候才会notify呢？在jvm源码里：

// 位于/hotspot/src/share/vm/runtime/thread.cpp中
void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
    // ...

    // Notify waiters on thread object. This has to be done after exit() is called
    // on the thread (if the thread is the last thread in a daemon ThreadGroup the
    // group should have the destroyed bit set before waiters are notified).
    // 有一个贼不起眼的一行代码，就是这行
    ensure_join(this);

    // ...
}


static void ensure_join(JavaThread* thread) {
    // We do not need to grap the Threads_lock, since we are operating on ourself.
    Handle threadObj(thread, thread->threadObj());
    assert(threadObj.not_null(), "java thread object must exist");
    ObjectLocker lock(threadObj, thread);
    // Ignore pending exception (ThreadDeath), since we are exiting anyway
    thread->clear_pending_exception();
    // Thread is exiting. So set thread_status field in  java.lang.Thread class to TERMINATED.
    java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
    // Clear the native thread instance - this makes isAlive return false and allows the join()
    // to complete once we've done the notify_all below
    java_lang_Thread::set_thread(threadObj(), NULL);

    // 同志们看到了没，别的不用看，就看这一句
    // thread就是当前线程，是啥？就是刚才例子中说的threadA线程啊。
    lock.notify_all(thread);

    // Ignore pending exception (ThreadDeath), since we are exiting anyway
    thread->clear_pending_exception();
}

个人理解结合上面的源码，当主线程调用了一个线程(A)的join()方法，和主线程调用wait()方法是一样的，都是让主线程等待，只不过此时线程A执行完后会调用notify()方法。

interrupt方法

Thread类的实例方法：中断被调用线程，实际上只是改变了被调用线程 的内部中断状态，并不会中断线程，但是否真的结束线程运行，并不是由Java来完成的，需要开发者自己判断此标记，适当位置时机结束线程运行，
调用此方法的线程如果正处于sleep状态，则会报InterruptedException异常
另外还有两个与此方法相关的要区分，

• interrupted方法（静态方法）
  测试该线程对象是否被中断，会清除中断标志位
• isInterrupted方法
  测试该线程对象是否被中断，不会清除中断标志位
  参考: https://blog.csdn.net/u010983881/article/details/80257703