Object 类线程相关

wait()

一个线程调用一个共享变量的 wait() 方法时，该线程会被阻塞挂起，直到发生以下事件才返回：

  1. 其他线程调用了该对象的 notify() 或 notifyAll() 方法
  2. 其他线程调用了该线程的 interrupt() 方法，该线程抛 InterruptedException 返回

如果调用 wait() 方法的线程没有获取该对象的监视器锁，则调用 wait() 方法时该线程会抛 IllegalMonitorStateException 异常。

如何获取共享变量的监视器锁？

  1. 执行 synchronized 同步代码块时，使用该共享变量作为参数
  2. 被 synchronized 修饰的方法，调用该共享变量

wait()有可能发生虚假唤醒，也就是没有通知、中断或等待超时就切换到可运行状态了。
所以 wait() 必须在 while(condition) 循环中，防止虚假唤醒：

  1. synchronized(obj) {
  2.     while (条件不满足) {
  3.         obj.wait();
  4.     }
  5. }

wait(long timeout)

timeout 毫秒后返回，如果 timeout 为0，则和 wait() 方法一样。

nofity()

唤醒一个在共享变量上调用 wait 系列方法被挂起的线程去竞争锁，具体唤醒哪个随机。
被唤醒的线程不是马上从 wait 方法返回，而是要在获取了共享对象的监视器锁后才可以返回，只有该线程竞争到了锁才能继续执行。

notifyAll()

唤醒所有在该共享变量上调用 wait 方法而被挂起的线程去竞争锁。

Thread 类

join()

等到线程终止

sleep()

让出指定时间的执行权，期间不参与 CPU 调度，但不释放锁。

yield()

让出 CPU 执行权，然后处于就绪状态，不被阻塞挂起，也不释放锁。

void interrupt()

中断线程
设置中断标志为 true，如果该线程没有被 wait、join、sleep，该线程会继续往下执行。

boolean isInterrupted()

判断实例对象是否被中断，不清除中断标志

static boolean interrupted()

检测当前线程是否被中断，是返回 true，并清除中断标志
该方法是静态方法，可以通过 Thread.interrupted() 调用
注意是当前线程，不是实例对象的

守护线程与用户线程

JVM启动时会调用 main 函数，main 函数所在的线程就是一个用户线程。
JVM 同时还启动了其他守护线程，比如垃圾回收线程。

所有用户线程都结束时，JVM 会退出，不管当前是否有守护线程。
设置 线程的 daemon 参数为 true，就是守护线程。

线程状态

  1. /**内部类，线程状态*/
  2. public enum State {
  3.     // 还没启动
  4.     NEW,
  5.     // 可运行状态 正在执行，或等待资源
  6.     RUNNABLE,
  7.     // 阻塞
  8.     BLOCKED,
  9.     // 等待， 死等，除非被其他线程唤醒 Object.wait()
  10.     WAITING,
  11.     // 具有指定等待时间的等待
  12.     TIMED_WAITING,
  13.     // 终止
  14.     TERMINATED;
  15. }

wait、sleep 区别

1.所属的类不同，wait => Object， sleep => Thread
2.调用 wait 会释放锁，sleep 不会释放锁。
3.wait (和 notify)必须在 synchronized 块中调用，sleep 没有约束

Thread 部分源码

  1. class Thread implements Runnable {
  2.     /* 类加载时 先 注册本地方法 
  3.      * 将Thread类中的java方法和一个本地的C/C++函数进行对应
  4.     */
  5.     private static native void registerNatives();
  6.     static {
  7.         registerNatives();
  8.     }
  9.     // 每个线程有自己的名称用来标识自己。但可能多个线程会重名，如果启动时没有创建名字，会自动生成一个。
  10.     private volatile String name;
  11.     // 线程的优先级（最大值为10，最小值为1，默认值为5）
  12.     private int            priority;
  14.     /* 线程是否是守护进程线程。*/
  15.     private boolean     daemon = false;
  17.     /* 要执行的任务 */
  18.     private Runnable target;
  20.     /* 此线程的组 */
  21.     private ThreadGroup group;
  23.     /* 此线程的上下文类加载器 */
  24.     private ClassLoader contextClassLoader;
  26.     /* 。。。。 */
  27.     private AccessControlContext inheritedAccessControlContext;
  29.     /* 用于自动为匿名线程编号. */
  30.     private static int threadInitNumber;
  31.     private static synchronized int nextThreadNum() {
  32.         return threadInitNumber++;
  33.     }
  35.     /* 与此线程相关的ThreadLocal值. 
  36.      * 此 map 由ThreadLocal类维护. */
  37.     ThreadLocal.ThreadLocalMap threadLocals = null;
  39.     /*
  40.      * 与此线程相关的InheritableThreadLocal值. 
  41.      * 此映射由InheritableThreadLocal类维护.
  42.      */
  43.     ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
  45.     /*
  46.      * 此线程请求的堆栈大小，如果创建者未指定堆栈大小，则为0。这取决于虚拟机对这个数字做任何它喜欢的事情；有些虚拟机会忽略它
  47.      */
  48.     private long stackSize;
  50.     /*
  51.      * 在本机线程终止后持续存在的JVM私有状态。
  52.      */
  53.     private long nativeParkEventPointer;
  55.     /*
  56.      * Thread ID
  57.      */
  58.     private long tid;
  60.     /* 用于生成线程ID */
  61.     private static long threadSeqNumber;
  63.     /* 线程状态*/
  64.     private volatile int threadStatus = 0;
  66.     /* 用于生成线程ID */
  67.     private static synchronized long nextThreadID() {
  68.         return ++threadSeqNumber;
  69.     }
  71.     /**
  72.      * The argument supplied to the current call to
  73.      * java.util.concurrent.locks.LockSupport.park.
  74.      * Set by (private) java.util.concurrent.locks.LockSupport.setBlocker
  75.      * Accessed using java.util.concurrent.locks.LockSupport.getBlocker
  76.      */
  77.     volatile Object parkBlocker;
  79.     /* The object in which this thread is blocked in an interruptible I/O
  80.      * operation, if any.  The blocker's interrupt method should be invoked
  81.      * after setting this thread's interrupt status.
  82.      */
  83.     private volatile Interruptible blocker;
  84.     private final Object blockerLock = new Object();
  86.     /* 设置拦截器字段；从java.nio代码通过sun.misc.SharedSecrets调用*/
  87.     void blockedOn(Interruptible b) {
  88.         synchronized (blockerLock) {
  89.             blocker = b;
  90.         }
  91.     }
  93.     /** 线程可以具有的最小优先级。*/
  94.     public final static int MIN_PRIORITY = 1;
  96.     /** 分配给线程的默认优先级。*/
  97.     public final static int NORM_PRIORITY = 5;
  99.     /** 线程可以拥有的最大优先级。*/
  100.     public final static int MAX_PRIORITY = 10;
  102.     /** 返回当前正在执行的线程 */
  103.     public static native Thread currentThread();
  105.     /**让出 CPU 时间片*/
  106.     public static native void yield();
  108.     /** 使当前正在执行的线程休眠（暂时停止）不会释放锁 单位：毫秒 */
  109.     public static native void sleep(long millis) throws InterruptedException;
  111.     /**
  112.      * nanos 时间延长 多少 纳秒，超过 50000 millis++ 执行的还是 sleep(long millis)
  113.      */
  114.     public static void sleep(long millis, int nanos)
  115.     throws InterruptedException {。。。}
  117.     private void init(ThreadGroup g, Runnable target, String name,
  118.                       long stackSize) {
  119.         init(g, target, name, stackSize, null, true);
  120.     }
  122.     /**
  123.      * 初始化线程
  124.      *
  125.      * g 线程组
  126.      * target 调用其run（）方法的对象
  127.      * name 新线程的名称
  128.      * stackSize 新线程所需的堆栈大小，零表示要忽略此参数。
  129.      * acc 安全控制器 要继承的AccessControlContext，如果为null 则为 AccessController.getContext（）
  130.      * inheritThreadLocals 继承的 ThreadLocal
  131.      */
  132.     private void init(ThreadGroup g, Runnable target, String name,
  133.                       long stackSize, AccessControlContext acc,
  134.                       boolean inheritThreadLocals) {。。。}
  136.     /**Thread类不支持克隆*/
  137.     @Override
  138.     protected Object clone() throws CloneNotSupportedException {
  139.         throw new CloneNotSupportedException();
  140.     }
  142.     /**无参的构造方法*/
  143.     public Thread() {
  144.         init(null, null, "Thread-" + nextThreadNum(), 0);
  145.     }
  146.     /** 启动线程，这个方法是个同步的方法 最终调用 start0 */
  147.     public synchronized void start() {}
  149.     /**真正启动线程的方法*/
  150.     private native void start0();
  152.     /**实现 Runnable 接口的 run 方法*/
  153.     @Override
  154.     public void run() {
  155.         if (target != null) {
  156.             target.run();
  157.         }
  158.     }
  160.     /**这个方法是JVM调用的，用来做一些清理工作*/
  161.     private void exit() {}
  163.     /**过时了*/
  164.     @Deprecated
  165.     public final void stop() {}
  167.     /**过时了*/
  168.     @Deprecated
  169.     public final synchronized void stop(Throwable obj) {
  170.         throw new UnsupportedOperationException();
  171.     }
  173.     /**中断线程*/
  174.     public void interrupt() {
  175.         if (this != Thread.currentThread())
  176.             checkAccess();
  178.         synchronized (blockerLock) {
  179.             Interruptible b = blocker;
  180.             if (b != null) {
  181.                 interrupt0();           // Just to set the interrupt flag
  182.                 b.interrupt(this);
  183.                 return;
  184.             }
  185.         }
  186.         interrupt0();
  187.     }
  189.     /** 检测当前线程是否被中断，是返回 true，并清除中断标志
  190.     该方法是静态方法，可以通过 Thread.interrupted() 调用
  191.     注意是当前线程，不是实例对象的
  192.     */
  193.     public static boolean interrupted() {
  194.         return currentThread().isInterrupted(true);
  195.     }
  197.     /**判断 实例对象线程 是否被中断
  198.         传 false，不清除中断标志
  199.     */
  200.     public boolean isInterrupted() {
  201.         return isInterrupted(false);
  202.     }
  204.     /**判断 实例对象线程 是否被中断 参数：是否清除中断标识*/
  205.     private native boolean isInterrupted(boolean ClearInterrupted);
  207.     /**过时了*/
  208.     @Deprecated
  209.     public void destroy() {
  210.         throw new NoSuchMethodError();
  211.     }
  213.     /** native 方法，判断线程是否还活着*/
  214.     public final native boolean isAlive();
  216.     /**过时了*/
  217.     @Deprecated
  218.     public final void suspend() {
  219.         checkAccess();
  220.         suspend0();
  221.     }
  223.     /**过时了*/
  224.     @Deprecated
  225.     public final void resume() {
  226.         checkAccess();
  227.         resume0();
  228.     }
  230.     /**设置优先级*/
  231.     public final void setPriority(int newPriority) {
  232.         ThreadGroup g;
  233.         checkAccess();
  234.         if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
  235.             throw new IllegalArgumentException();
  236.         }
  237.         if((g = getThreadGroup()) != null) {
  238.             if (newPriority > g.getMaxPriority()) {
  239.                 newPriority = g.getMaxPriority();
  240.             }
  241.             setPriority0(priority = newPriority);
  242.         }
  243.     }
  245.     /**获取优先级*/
  246.     public final int getPriority() {
  247.         return priority;
  248.     }
  250.     /**设置线程的名称*/
  251.     public final synchronized void setName(String name) {
  252.         checkAccess();
  253.         if (name == null) {
  254.             throw new NullPointerException("name cannot be null");
  255.         }
  257.         this.name = name;
  258.         if (threadStatus != 0) {
  259.             setNativeName(name);
  260.         }
  261.     }
  263.     /**获取线程名称*/
  264.     public final String getName() {
  265.         return name;
  266.     }
  268.     /**获取线程的线程组*/
  269.     public final ThreadGroup getThreadGroup() {
  270.         return group;
  271.     }
  273.     /**获取当前线程所在线程组的活跃线程数，这个值是动态的*/
  274.     public static int activeCount() {
  275.         return currentThread().getThreadGroup().activeCount();
  276.     }
  278.     /**将当前进程中的每个活动线程复制到指定的数组中*/
  279.     public static int enumerate(Thread tarray[]) {
  280.         return currentThread().getThreadGroup().enumerate(tarray);
  281.     }
  283.     /**过期了*/
  284.     @Deprecated
  285.     public native int countStackFrames();
  287.     /**等该实例对象线程终止，最多等 millis 毫秒， 0表示一直等到终止*/
  288.     public final synchronized void join(long millis)
  289.     throws InterruptedException {
  290.         long base = System.currentTimeMillis();
  291.         long now = 0;
  293.         if (millis < 0) {
  294.             throw new IllegalArgumentException("timeout value is negative");
  295.         }
  297.         if (millis == 0) {
  298.             while (isAlive()) {
  299.                 wait(0);
  300.             }
  301.         } else {
  302.             while (isAlive()) {
  303.                 long delay = millis - now;
  304.                 if (delay <= 0) {
  305.                     break;
  306.                 }
  307.                 wait(delay);
  308.                 now = System.currentTimeMillis() - base;
  309.             }
  310.         }
  311.     }
  313.     /**同上 nanos 超过50万 millis++ */
  314.     public final synchronized void join(long millis, int nanos)
  315.     throws InterruptedException {。。。}
  317.     /**一直等到线程终止*/
  318.     public final void join() throws InterruptedException {
  319.         join(0);
  320.     }
  322.     /**打印堆栈，只有debugg的时候使用，平时别用*/
  323.     public static void dumpStack() {
  324.         new Exception("Stack trace").printStackTrace();
  325.     }
  327.     /**设置守护线程标志，记得是启动前设置*/
  328.     public final void setDaemon(boolean on) {
  329.         checkAccess();
  330.         if (isAlive()) {
  331.             throw new IllegalThreadStateException();
  332.         }
  333.         daemon = on;
  334.     }
  336.     /**判断线程是否是守护线程*/
  337.     public final boolean isDaemon() {
  338.         return daemon;
  339.     }
  341.     /**检查当前线程是否有权限操作这个实例线程*/
  342.     public final void checkAccess() {
  343.         SecurityManager security = System.getSecurityManager();
  344.         if (security != null) {
  345.             security.checkAccess(this);
  346.         }
  347.     }
  349.     /**打印线程的字符串*/
  350.     public String toString() {
  351.         ThreadGroup group = getThreadGroup();
  352.         if (group != null) {
  353.             return "Thread[" + getName() + "," + getPriority() + "," +
  354.                            group.getName() + "]";
  355.         } else {
  356.             return "Thread[" + getName() + "," + getPriority() + "," +
  357.                             "" + "]";
  358.         }
  359.     }
  361.     /**获取ClassLoader，注意CallerSensitive这个注解，调用者必须有权限*/
  362.     @CallerSensitive
  363.     public ClassLoader getContextClassLoader() {
  364.         if (contextClassLoader == null)
  365.             return null;
  366.         SecurityManager sm = System.getSecurityManager();
  367.         if (sm != null) {
  368.             ClassLoader.checkClassLoaderPermission(contextClassLoader,
  369.                                                    Reflection.getCallerClass());
  370.         }
  371.         return contextClassLoader;
  372.     }
  374.     /**设置这个ClassLoader*/
  375.     public void setContextClassLoader(ClassLoader cl) {
  376.         SecurityManager sm = System.getSecurityManager();
  377.         if (sm != null) {
  378.             sm.checkPermission(new RuntimePermission("setContextClassLoader"));
  379.         }
  380.         contextClassLoader = cl;
  381.     }
  383.     /**native方法，判断是否持有锁*/
  384.     public static native boolean holdsLock(Object obj);
  386.     /**栈帧数组*/
  387.     private static final StackTraceElement[] EMPTY_STACK_TRACE
  388.         = new StackTraceElement[0];
  390.     /**获取线程栈帧*/
  391.     public StackTraceElement[] getStackTrace() {...}
  393.     /**获取所有线程的ThreadDump*/
  394.     public static Map<Thread, StackTraceElement[]> getAllStackTraces() {...}
  396.     ...
  398.     private native static StackTraceElement[][] dumpThreads(Thread[] threads);
  399.     private native static Thread[] getThreads();
  401.     /**获取id*/
  402.     public long getId() {
  403.         return tid;
  404.     }
  406.     /**内部类，线程状态*/
  407.     public enum State {
  408.         // 还没启动
  409.         NEW,
  410.       // 可运行状态 正在执行，或等待资源
  411.         RUNNABLE,
  412.       // 阻塞
  413.         BLOCKED,
  414.       // 等待， 死等，除非被其他线程唤醒 Object.wait()
  415.         WAITING,
  416.         // 具有指定等待时间的等待
  417.         TIMED_WAITING,
  418.       // 终止
  419.         TERMINATED;
  420.     }
  422.     /**获取线程状态*/
  423.     public State getState() {
  424.         // get current thread state
  425.         return sun.misc.VM.toThreadState(threadStatus);
  426.     }
  428.     // Added in JSR-166
  430.     /**未检查异常处理器 
  431.     函数式接口 可以使用Lambda表达式来表示该接口的一个实现 */
  432.     @FunctionalInterface
  433.     public interface UncaughtExceptionHandler {
  434.         /**线程执行任务过程中出现未检查异常时，JVM会调用这个方法*/
  435.         void uncaughtException(Thread t, Throwable e);
  436.     }
  438.     // 未检查异常处理器 除非显式设置，否则为null
  439.     private volatile UncaughtExceptionHandler uncaughtExceptionHandler;
  441.     // 默认的未检查异常处理器
  442.     private static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;
  444.     /**设置 默认的未检查异常处理器*/
  445.     public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
  446.         SecurityManager sm = System.getSecurityManager();
  447.         if (sm != null) {
  448.             sm.checkPermission(
  449.                 new RuntimePermission("setDefaultUncaughtExceptionHandler")
  450.                     );
  451.         }
  453.          defaultUncaughtExceptionHandler = eh;
  454.      }
  456.     /**获取 默认的未检查异常处理器*/
  457.     public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler(){
  458.         return defaultUncaughtExceptionHandler;
  459.     }
  461.     /**获取 未检查异常处理器*/
  462.     public UncaughtExceptionHandler getUncaughtExceptionHandler() {
  463.         return uncaughtExceptionHandler != null ?
  464.             uncaughtExceptionHandler : group;
  465.     }
  467.     /**设置 未检查异常处理器*/
  468.     public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
  469.         checkAccess();
  470.         uncaughtExceptionHandler = eh;
  471.     }
  473.     /** 将异常转发给处理器，这个方法只会被JVM调用 */
  474.     private void dispatchUncaughtException(Throwable e) {
  475.         getUncaughtExceptionHandler().uncaughtException(this, e);
  476.     }
  478.     /**清理引用队列 。。。*/
  479.     static void processQueue(ReferenceQueue<Class<?>> queue,
  480.                              ConcurrentMap<? extends
  481.                              WeakReference<Class<?>>, ?> map)
  482.     {
  483.         Reference<? extends Class<?>> ref;
  484.         while((ref = queue.poll()) != null) {
  485.             map.remove(ref);
  486.         }
  487.     }
  489.     /**类对象的弱键**/
  490.     static class WeakClassKey extends WeakReference<Class<?>> {}
  493.     // The following three initially uninitialized fields are exclusively
  494.     // managed by class java.util.concurrent.ThreadLocalRandom. These
  495.     // fields are used to build the high-performance PRNGs in the
  496.     // concurrent code, and we can not risk accidental false sharing.
  497.     // Hence, the fields are isolated with @Contended.
  499.     /** 实例线程的随机种子 */
  500.     /** @sun.misc.Contended("tlr") 避免多线程下的伪共享，提升效率 */
  501.     @sun.misc.Contended("tlr")
  502.     long threadLocalRandomSeed;
  504.     /** 用来计算随机种子; 随机种子未初始化时为 0 */
  505.     @sun.misc.Contended("tlr")
  506.     int threadLocalRandomProbe;
  508.     /** 用来计算随机种子; 从公共随机序列中分离出二级种子 */
  509.     @sun.misc.Contended("tlr")
  510.     int threadLocalRandomSecondarySeed;
  512.     /* 私有 原生方法 */
  513.     private native void setPriority0(int newPriority);
  514.     private native void stop0(Object o);
  515.     private native void suspend0();
  516.     private native void resume0();
  517.     private native void interrupt0();
  518.     private native void setNativeName(String name);
  519. }