JDK1.8 Thread类说明

Posted 2023-02-18 zhujm320

简介

      Thread Java线程类，用于线程相关操作，是并发和多线程的基础。本文将对Thread源码和日常使用的函数进行解读。在对线程的使用有基本的了解后，再来阅读它的源码，有助于加深对线程的理解；如有小伙伴对线程的使用不是很清楚的话，请参考《Java开启线程的4种方式》。

线程是操作系统中的概念，也是系统调度的基本单元。对于线程的创建，通常通过系统的API来进行创建，Thread的线程创建也是通过系统API来进行创建，Thread只是对系统线程的一个包装。

构造函数

初始化线程

 private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) 
        init(g, target, name, stackSize, null, true);
 

参数说明

参数	说明
ThreadGroup g	线程组
Runnable target	线程启动后，线程中回调run的目标对象
String name	线程名
long stackSize	线程栈大小

调用6参得初始化线程函数

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals)

参数说明

参数	说明
ThreadGroup g	线程组
Runnable target	线程回调run方法
String name	线程名字
long stackSize	线程堆栈大小
AccessControlContext acc	上下文
boolean inheritThreadLocals	是否继承ThreadLocals的值

无参构造函数

public Thread() 
        init(null, null, "Thread-" + nextThreadNum(), 0);
    

带一个参数构造函数

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

参数	说明
Runnable target	线程回调后的目标对象

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

参数	说明
String name	线程名

带两个参数的构造函数

Thread(Runnable target, AccessControlContext acc) 
        init(null, target, "Thread-" + nextThreadNum(), 0, acc, false);
    

参数	说明
Runnable target	线程回调后的目标对象
AccessControlContext acc	系统资源访问决策类

 public Thread(ThreadGroup group, Runnable target) 
        init(group, target, "Thread-" + nextThreadNum(), 0);
    

参数	说明
ThreadGroup group	线程组
Runnable target	线程回调后的目标对象

public Thread(ThreadGroup group, String name) 
        init(group, null, name, 0);
    

参数	说明
ThreadGroup group	线程组
String name	线程名

带三个参数的构造函数

public Thread(ThreadGroup group, Runnable target, String name) 
        init(group, target, name, 0);
    

参数	说明
ThreadGroup group	线程组
Runnable target	线程回调后的目标对象
String name	线程名

带四个参数的构造函数

public Thread(ThreadGroup group, Runnable target, String name,
                  long stackSize) 
        init(group, target, name, stackSize);
    

参数	说明
ThreadGroup group	线程组
Runnable target	线程回调后的目标对象
String name	线程名
long stackSize	线程堆栈大小

从以上看，Thread构造函数都是通过调用init函数进行初始化。

线程启动函数

通过调用Thread类的start()函数，线程正式启动，并且会调用run方法，此时run方法就是在线程中执行。

 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)
            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);

        boolean started = false;
        try 
            start0();
            started = true;
         finally 
            try 
                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方法只能调用一次，多次调用会包异常，start方法通过jni方法start0启动线程，由于Thread类只是对系统线程的一个封装，通过start0启动系统线程，启动线程启动后，通过jni回调run方法。

线程运行run方法

 @Override
    public void run() 
        if (target != null) 
            target.run();
        
    

线程真正运行的地方，系统线程启动后，回调run方法，所以说在start后，run方法是在线程中执行。

Native方法

//获取当前运行线程对象
public static native Thread currentThread();
//线程礼让, 让出自己的cpu，让别人执行
public static native void yield();
//线程休眠 单位毫秒
public static native void sleep(long millis) throws InterruptedException;
//线程启动的真正方法
private native void start0();
//线程是否活着
public final native boolean isAlive();
//设置线程优先级
private native void setPriority0(int newPriority);
//停止线程
private native void stop0(Object o);
//暂停线程
private native void suspend0();
//唤醒线程
private native void resume0();
//中断线程
private native void interrupt0();
//设置线程名字
private native void setNativeName(String name);

线程退出

private void exit() 
        if (group != null) 
            group.threadTerminated(this);
            group = null;
        
        /* Aggressively null out all reference fields: see bug 4006245 */
        target = null;
        /* Speed the release of some of these resources */
        threadLocals = null;
        inheritableThreadLocals = null;
        inheritedAccessControlContext = null;
        blocker = null;
        uncaughtExceptionHandler = null;
    

线程退出函数，调用该函数后，线程不一定会真正退出，如果在run方法中执行如下代码:

public void run()
	while(true)
		....
	

这样线程就无法退出了

线程中断通知

   public void interrupt() 
        if (this != Thread.currentThread())
            checkAccess();
        synchronized (blockerLock) 
            Interruptible b = blocker;
            if (b != null) 
                interrupt0();           // Just to set the interrupt flag
                b.interrupt(this);
                return;
            
        
        interrupt0();

给真正运行的线程发送中断通知，以便该线程在执行时，能够收到该中断 

public void run()
	while(true)
		try
			...
		catch(Exception e)
		    ...
		
	

在run方法中进行异常捕获，当线程发起中断通知时，以便在线程中能收到。如果在run方法中没有去捕获异常的话，那么即使调用interrupt()，线程也是无法得到中断通知。

 public static boolean interrupted() 
        return currentThread().isInterrupted(true);
    

测试该线程是否已经进行中断，重置当前线程的中断状态。

public boolean isInterrupted() 
        return isInterrupted(false);
    

判断该线程是否中断，不会清楚线程中断状态

设置线程优先级

public final void setPriority(int newPriority) 
        ThreadGroup g;
        checkAccess();
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) 
            throw new IllegalArgumentException();
        
        if((g = getThreadGroup()) != null) 
            if (newPriority > g.getMaxPriority()) 
                newPriority = g.getMaxPriority();
            
            setPriority0(priority = newPriority);
        
    

线程优先级从小到大分为1-10个等级，默认优先级为5

获取线程优先级

public final int getPriority() 
        return priority;
    

设置线程名字

public final synchronized void setName(String name) 
        checkAccess();
        if (name == null) 
            throw new NullPointerException("name cannot be null");
        

        this.name = name;
        if (threadStatus != 0) 
            setNativeName(name);
        
    

给线程设置一个名字

获取线程名字

public final String getName() 
    return name;

join方法(停止当前线程执行另外一个线程，另外一个线程结束后再执行本线程)

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;
            
        
    

    /**
     * Waits at most @code millis milliseconds plus
     * @code nanos nanoseconds for this thread to die.
     *
     * <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
     *
     * @param  nanos
     *         @code 0-999999 additional nanoseconds to wait
     *
     * @throws  IllegalArgumentException
     *          if the value of @code millis is negative, or the value
     *          of @code nanos is not in the range @code 0-999999
     *
     * @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(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");
        

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) 
            millis++;
        

        join(millis);
    

    /**
     * Waits for this thread to die.
     *
     * <p> An invocation of this method behaves in exactly the same
     * way as the invocation
     *
     * <blockquote>
     * @linkplain #join(long) join@code (0)
     * </blockquote>
     *
     * @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 void join() throws InterruptedException 
        join(0);
    

 

执行流程图如下:

join方法中，有下面这段

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;
            
        
    

也就是说在哪一个线程中调用了join方法，那么它就等待，直到join对象的那个线程退出，例子如下:

public static void main(String[] args) 
        Thread t1 = new Thread(()->
            System.out.println("t1 start...");
            Thread t2 = new Thread(()->
                System.out.println("t2 start...");
                try
                    Thread.sleep(2000);
                catch (Exception e)
                    e.printStackTrace();
                
                System.out.println("t2 end...");
            );
            t2.start();
            try 
                t2.join();
             catch (InterruptedException e) 
                e.printStackTrace();
            
            System.out.println("t1 end...");
        );
        t1.start();
    

执行结果:

t1 start...
t2 start...
t2 end...
t1 end...

在线程t1中启动线程t2，然后调用t2.join方法，那么t2.join是在t1线程中执行的，t1将阻塞直到t2运行结束。

获取类加载器

public ClassLoader getContextClassLoader() 
        if (contextClassLoader == null)
            return null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) 
            ClassLoader.checkClassLoaderPermission(contextClassLoader,
                                                   Reflection.getCallerClass());
        
        return contextClassLoader;
    

类加载器用来加载一些class文件

设置类加载器

public void setContextClassLoader(ClassLoader cl) 
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) 
            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
        
        contextClassLoader = cl;
    

获取线程ID

public long getId() 
        return tid;
    

线程状态

public enum State 
        /**
         * NEW状态: 并没有调用start方法
         */
        NEW,

        /**
         * 可执行状态: 调用start方法
         */
        RUNNABLE,

        /**
         * 阻塞状态，在run中调用了wait或者synchronized方法导致了阻塞
         */
        BLOCKED,

        /**
         * 等待状态: 调用Object.wait()后的状态
         */
        WAITING,

        /**
         * 等待超时状态: 调用Object.wait(timeOut), timeOut结束后的状态
         */
        TIMED_WAITING,

        /**
         * 结束状态: 线程结束状态
         */
        TERMINATED;
    

状态切换图:

win32下Thread简单实现源码