java.lang.*中Thread 源代码详解

拼搏现实的明天。 2022-12-15 12:40 15阅读 0赞

### java.lang.\*中Thread 源代码详解 ###

*   *  核心方法
     *  线程优先级
     *  线程状态
     *  void sleep(long millis, int nanos)
     *  public Thread()
     *  public Thread(Runnable target)
     *  public Thread(String name)
     *  synchronized void start()
     *  void run()
     *  void interrupt()
     *  boolean interrupted()
     *  void setPriority(int newPriority)
     *  int getPriority()
     *  synchronized void setName(String name)
     *  final String getName()
     *  ThreadGroup getThreadGroup()
     *  int activeCount()
     *  int enumerate(Thread tarray\[\])
     *  synchronized void join(long millis)
     *  void dumpStack()
     *  void setDaemon(boolean on)
     *  final boolean isDaemon()
     *  final void checkAccess()
     *  String toString()
     *  ClassLoader \`在这里插入代码片\`getContextClassLoader()
     *  void setContextClassLoader(ClassLoader cl)
     *  StackTraceElement\[\] getStackTrace()
     *  enum State
     *  State getState()

> 学习Java的同学注意了！！！  
> 学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：543120397 我们一起学Java！

## 核心方法 ##

public class Thread implements Runnable { 
    
    native Thread currentThread() 获取当前正在执行的线程
    native void yield() 释放当前线程CPU执行权
    native void sleep(long millis) 让线程睡眠millis毫秒(释放线程锁)
    void sleep(long millis, int nanos) 让线程睡眠mills毫秒(释放线程锁)
    public Thread() 构造函数
    public Thread(Runnable target) 构造函数
    public Thread(String name) 构造函数
    synchronized void start() 执行此线程(多线程)
    void run() 执行此线程(单线程)
    void interrupt() 中断当前线程
    boolean interrupted() 判断当前线程是否被中断
    void setPriority(int newPriority) 修改线程优先级
    int getPriority() 获取线程优先级
    synchronized void setName(String name) 设置当前线程名称
    final String getName() 获取当前线程名称
    ThreadGroup getThreadGroup() 获取当前线程组
    int activeCount() 获取当前线程组的活跃线程的估值
    int enumerate(Thread tarray[]) 将当前线程组及其子组中的活跃线程赋值给tarray
    synchronized void join(long millis) 等待这个线程死亡
    void dumpStack() 将当前线程的堆栈跟踪打印到标准错误流
    void setDaemon(boolean on) 将当前线程记为Daemon线程或者用户线程
    final boolean isDaemon() 判断当前线程是否为Daemon线程
    final void checkAccess() 判断当前运行的线程是否有修改此线程的权限
    String toString() 获取线程对象的字符串形式
    ClassLoader getContextClassLoader() 返回当前线程的上下文类加载器
    void setContextClassLoader(ClassLoader cl) 设置当前线程的上下文类加载器
    StackTraceElement[] getStackTrace() 返回当前线程的堆栈转存的堆栈跟踪元素数组
    enum State 线程状态的内部枚举类
    State getState() 获取当前线程的状态

## 线程优先级 ##

/** * 1.线程执行有优先级,优先级越高,先执行机会越大 * 2.优先级使用int类型的priority表示 * 3.线程优先级最高为10 * 最低为1 * 默认为5 */
    public final static int MIN_PRIORITY = 1;
    public final static int NORM_PRIORITY = 5;
    public final static int MAX_PRIORITY = 10;

## 线程状态 ##

/** * 1.线程共有6种状态,状态转化关系如下图 * 2.有一种说法: 线程只有“就绪”，“阻塞”，“运行”三种状态，因为 * 新建[NEW]和终止[TERMINATED]状态的线程并是不线程，只是代 * 表一个线程对象还存在 * 3.RUNNABLE代表就绪和运行两种状态，也就是说处于就绪和运行两 * 种状态的线程，在java.lang.Thread中都表现为RUNNABLE状态 * 4.BLOCKED,对应阻塞状态,此线程需要所得锁资源,才能继续执行,而 * 这个锁当前正被其他线程所占有,所以进入了被动等待状态,直到再 * 次获取到锁资源,才能进入到就绪状态 * 5.WAITING,对应阻塞状态,代表此线程进入无限期的主动等待状态, * 直到有人唤醒它,它才会再次进入就绪状态 * 6.TIMED_WAITING,对应阻塞状态,代表此线程处于有限期的主动等 * 待状态,要么有人唤醒它,要么等待完指定时间后,才会再次进入就 * 绪状态 */
    public enum State { 
    	NEW,(新建状态)
    	RUNNABLE,(可运行状态)
    	BLOCKED,(阻塞状态)
    	WAITING,(等待状态)
    	TIMED_WAITING,(有时间等待状态)
    	TERMINATED;(终止状态)
    }

![线程状态转化关系图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNDQ2Njg_size_16_color_FFFFFF_t_70_pic_center]

## void sleep(long millis, int nanos) ##

/** * 睡眠指定时间 * @param millis * @param nanos */
    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");
        }
    	
    	//合法的情况下,mills++
        if (nanos >= 500000 || (nanos != 0 && millis == 0)) { 
            millis++;
        }
    
        sleep(millis);
    }

## public Thread() ##

/** * 构造函数 */
    public Thread() { 
        //nextThreadNum执行一次,自增一次,默认值是0
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }
    
    private void init(ThreadGroup g, Runnable target, String name, long stackSize) { 
    	init(g, target, name, stackSize, null);
    }
    
    /** * @param ThreadGroup g * @param Runnable target * @param String name * @param long stackSize * @param AccessControlContext acc */
    private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc) { 
    	//首先判断创建的新线程的ThreadName不能为空
        if (name == null) { 
            throw new NullPointerException("name cannot be null");
        }
    
        this.name = name.toCharArray();
    
    	//获取当前主线程
        Thread parent = currentThread();
        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依然为null,则获取parent线程组
                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;
        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 (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 */
        tid = nextThreadID();
    }

## public Thread(Runnable target) ##

public Thread(Runnable target) { 
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

## public Thread(String name) ##

public Thread(String name) { 
        init(null, null, name, 0);
    }

## synchronized void start() ##

public synchronized void start() { 
        
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
    	//将当前线程加入线程组
        group.add(this);
    
        boolean started = false;
        try { 
            start0();
            started = true;
        } finally { 
            try { 
                //如果线程启动失败,则将此线程移出线程组
                if (!started) { 
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) { 
                
            }
        }
    }

## void run() ##

/** * 执行此线程的方法 */
    public void run() { 
    	//target对象在init方法中被初始化,这里其实会调用子类本身的run方法,因为父类方法为抽象方法
        if (target != null) { 
            target.run();
        }
    }

## void interrupt() ##

public void interrupt() { 
    	// 如果不是当前线程，抛出SecurityException异常
        if (this != Thread.currentThread())
            checkAccess();
            
    	// 对blockerLock对象加锁
        synchronized (blockerLock) { 
            Interruptible b = blocker;
            if (b != null) { 
                interrupt0();           // Just to set the interrupt flag
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }

## boolean interrupted() ##

/** * 判断当前线程是否被中断 */
    public static boolean interrupted() { 
        return currentThread().isInterrupted(true);
    }
    
    private native boolean isInterrupted(boolean ClearInterrupted);

## void setPriority(int newPriority) ##

/** * 设置线程的优先级 */
    public final void setPriority(int newPriority) { 
        ThreadGroup g;
        //判断是否拥有修改此线程的权限
        checkAccess();
        //判断线程的优先级是否合法[1,10]
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) { 
            throw new IllegalArgumentException();
        }
        //如果newPriority>线程组的最大优先级的值,我们需要更新线程组的最大优先级
        if((g = getThreadGroup()) != null) { 
            if (newPriority > g.getMaxPriority()) { 
                newPriority = g.getMaxPriority();
            }
            //告诉JVM当前线程的优先级,同时赋值当前新的priotity属性
            setPriority0(priority = newPriority);
        }
    }

## int getPriority() ##

/** * 获取当前线程的优先级 */
    public final int getPriority() { 
        return priority;
    }

## synchronized void setName(String name) ##

/** * 设置当前线程名称 */
    public final synchronized void setName(String name) { 
        checkAccess();
        this.name = name.toCharArray();
        if (threadStatus != 0) { 
            setNativeName(name);
        }
    }

## final String getName() ##

/** * 获取当前线程名称 */
    public final String getName() { 
        return new String(name, true);
    }

## ThreadGroup getThreadGroup() ##

public final ThreadGroup getThreadGroup() { 
        return group;
    }

## int activeCount() ##

/** * 获取当前线程组的所有活跃线程估值 */
      
    public static int activeCount() { 
        return currentThread().getThreadGroup().activeCount();
    }
    
    public int activeCount() { 
    	//用来接收活跃线程数量
        int result;
        // Snapshot sub-group data so we don't hold this lock
        // while our children are computing.
        int ngroupsSnapshot;
        ThreadGroup[] groupsSnapshot;
        //增加代码块锁,this作为锁对象
        synchronized (this) { 
            if (destroyed) { //如果线程被销毁,直接返回0
                return 0;
            }
            //直接将当前线程组的数量,赋值给result
            result = nthreads;
            //将所有线程组对象赋值给ngroupsSnapshot 
            ngroupsSnapshot = ngroups;
            if (groups != null) { 
                groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
            } else { 
                groupsSnapshot = null;
            }
        }
        //将其他线程组的活跃线程数加和起来
        for (int i = 0 ; i < ngroupsSnapshot ; i++) { 
            result += groupsSnapshot[i].activeCount();
        }
        return result;
    }

## int enumerate(Thread tarray\[\]) ##

/** * 将当前线程组及其子组中的活跃线程赋值给tarray */
    public static int enumerate(Thread tarray[]) { 
        return currentThread().getThreadGroup().enumerate(tarray);
    }
    
    public int enumerate(Thread list[]) { 
        checkAccess();
        return enumerate(list, 0, true);
    }
    
    private int enumerate(Thread list[], int n, boolean recurse) { 
       int ngroupsSnapshot = 0;
       ThreadGroup[] groupsSnapshot = null;
       synchronized (this) { 
           if (destroyed) { 
               return 0;
           }
           int nt = nthreads;
           if (nt > list.length - n) { 
               nt = list.length - n;
           }
           for (int i = 0; i < nt; i++) { 
               if (threads[i].isAlive()) { //必须是活跃线程
                   list[n++] = threads[i];
               }
           }
           if (recurse) { 
               ngroupsSnapshot = ngroups;
               if (groups != null) { 
                   groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
               } else { 
                   groupsSnapshot = null;
               }
           }
       }
       if (recurse) { 
           for (int i = 0 ; i < ngroupsSnapshot ; i++) { 
               n = groupsSnapshot[i].enumerate(list, n, true);
           }
       }
       return n;
    }

## synchronized void join(long millis) ##

/** * 等待这个线程死亡 */
    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) { 
                	//如果delay<=0说明,时间已到,直接break跳出循环
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

## void dumpStack() ##

/** * 将当前线程的堆栈跟踪打印到标准错误流 */
    public static void dumpStack() { 
        new Exception("Stack trace").printStackTrace();
    }

## void setDaemon(boolean on) ##

/** * 将此线程标记为Daemon线程或者用户线程 */
    public final void setDaemon(boolean on) { 
       //检查当前是否有修改权限
       checkAccess();
       if (isAlive()) { 
           throw new IllegalThreadStateException();
       }
       daemon = on;
    }

## final boolean isDaemon() ##

/** * 判断当前线程是否为守护Daemon线程 */
    public final boolean isDaemon() { 
        return daemon;
    }

## final void checkAccess() ##

/** * 检查当前运行线程是否有修改此线程的权限 */
    public final void checkAccess() { 
        SecurityManager security = System.getSecurityManager();
        if (security != null) { 
            security.checkAccess(this);
        }
    }

## String toString() ##

/** * 获取线程对象的字符串形式 */
    public String toString() { 
        ThreadGroup group = getThreadGroup();
        if (group != null) { 
            return "Thread[" + getName() + "," + getPriority() + "," +
                           group.getName() + "]";
        } else { 
            return "Thread[" + getName() + "," + getPriority() + "," +
                            "" + "]";
        }
    }

## ClassLoader `在这里插入代码片`getContextClassLoader() ##

/** * 返回当前线程的上下文类加载器 */
    public ClassLoader getContextClassLoader() { 
        if (contextClassLoader == null)
            return null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) { 
            ClassLoader.checkClassLoaderPermission(contextClassLoader,
                                                   Reflection.getCallerClass());
        }
        return contextClassLoader;
    }

## void setContextClassLoader(ClassLoader cl) ##

/** * 设置当前线程的上下文类加载器对象 */
    public void setContextClassLoader(ClassLoader cl) { 
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) { 
            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
        }
        contextClassLoader = cl;
    }

## StackTraceElement\[\] getStackTrace() ##

/** * 返回当前线程的堆栈转存的堆栈跟踪元素数组 */
    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);
            }
            // optimization so we do not call into the vm for threads that
            // have not yet started or have terminated
            //判断当前线程是否为存活状态
            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) { 
                stackTrace = EMPTY_STACK_TRACE;
            }
            return stackTrace;
        } else { 
            // Don't need JVM help for current thread
            return (new Exception()).getStackTrace();
        }
    }

## enum State ##

public enum State { 
    	NEW,//新建状态
    	RUNNABLE,//可运行状态
    	BLOCKED,//阻塞状态
    	WAITING,//等待状态,需要被主动唤醒
    	TIMED_WAITING,//有时间等待状态
    	TERMINATED;//终止状态
    }

## State getState() ##

/** * 获取当前线程的状态 */
    public State getState() { 
        // get current thread state
        //调用VM虚拟机类的静态方法
        return sun.misc.VM.toThreadState(threadStatus);
    }
    
    public static State toThreadState(int var0) { 
        if ((var0 & 4) != 0) { 
            return State.RUNNABLE;
        } else if ((var0 & 1024) != 0) { 
            return State.BLOCKED;
        } else if ((var0 & 16) != 0) { 
            return State.WAITING;
        } else if ((var0 & 32) != 0) { 
            return State.TIMED_WAITING;
        } else if ((var0 & 2) != 0) { 
            return State.TERMINATED;
        } else { 
            return (var0 & 1) == 0 ? State.NEW : State.RUNNABLE;
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNDQ2Njg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/45de601f7b284e7d984e1f6d33aaf164.png