并发编程学习笔记（七、Thread源码分析）

目录：

• 常见属性
• 构造函数
• start()
• run()

常见属性：

 　　/**
      * 线程名称
      */
     private volatile String name;

     /**
      * 线程优先级
      */
     private int priority;

     /**
      * 是否为守护线程，true-是守护线程
      */
     private boolean daemon = false;

     /**
      * 可能被执行的Runnable
      */
     private Runnable target;

     /**
      * 所属线程组
      */
     private ThreadGroup group;

     /**
      * 当前线程所属的ThreadLocal
      */
     ThreadLocal.ThreadLocalMap threadLocals = null;

     /**
      * 为子线程提供父线程所继承的值
      */
     ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

     /**
      * 当前线程的栈大小，若不指定默认为0；如何使用这个数值取决于JVM
      */
     private long stackSize;

     /**
      * 线程的id
      */
     private long tid;

     /**
      * 线程序列号
      */
     private static long threadSeqNumber;

     /**
      * 线程状态，默认是未启动
      */
     private volatile int threadStatus = 0;

     /**
      * 得到下一个线程的序列号
      */
     private static synchronized long nextThreadID() {
         return ++threadSeqNumber;
     }

     /**
      * 为java.util.concurrent.locks.LockSupport.park提供的变量
      */
     volatile Object parkBlocker;

     /**
      * 阻塞器锁，主要处理阻塞状况
      */
     private volatile Interruptible blocker;

     /**
      * 阻断锁
      */
     private final Object blockerLock = new Object();

     /**
      * 最低优先级
      */
     public final static int MIN_PRIORITY = 1;

     /**
      * 默认优先级
      */
     public final static int NORM_PRIORITY = 5;

     /**
      * 最高优先级
      */
     public final static int MAX_PRIORITY = 10;

构造器：

我们看源码可以看出，所有的构造函数都是调用init()方法；所以我们来说说init()方法

 private void init(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();

     // -------------- 安全校验 start ----------------
     SecurityManager security = System.getSecurityManager();
     if (g == null) {
         if (security != null) {
             g = security.getThreadGroup();
         }

         if (g == null) {
             g = parent.getThreadGroup();
         }
     }

     g.checkAccess();

     if (security != null) {
         if (isCCLOverridden(getClass())) {
             security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
         }
     }
     // -------------- 安全校验 end ----------------

     // 记录一下未启动线程的个数
     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);
     }

     this.stackSize = stackSize;
     // 设置线程ID
     tid = nextThreadID();
 }

start()：

 public synchronized void start() {
     // 只能启动状态为未启动的线程
     if (threadStatus != 0) {
         throw new IllegalThreadStateException();
     }

     // 将当前线程添加到线程组中
     group.add(this);

     boolean started = false;
     try {
         // 将线程置为就绪状态，此函数为JVM层次的
         start0();
         started = true;
     } finally {
         try {
             // 启动失败后未启动线程数+1
             if (!started) {
                 group.threadStartFailed(this);
             }
         } catch (Throwable ignore) {

         }
     }
 }

 private native void start0();

run()：

 /**
  * 线程具体的执行逻辑
  */
 @Override
 public void run() {
     // 若有指定执行的Runnable，跑Runnable的具体逻辑
     if (target != null) {
         target.run();
     }
 }