Thread类学习

Posted 2022-03-24 gsanye

Thread类定义:

public class Thread implements Runnable

Thread类属性定义:

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

/**
*线程优先级 
*MIN_PRIORITY = 1
*NORM_PRIORITY = 5
*MAX_PRIORITY = 10
*/
private int priority;

/***守护线程标识*/
private boolean daemon = false;

/***目标任务*/
private Runnable target;

/**线程初始化编号**/
private static int threadInitNumber;

/**ThreadLocalMap ThreadLocal 存储Map*/
ThreadLocal.ThreadLocalMap threadLocals = null;

/**ThreadLocalMap 可继承的 ThreadLocal 存储Map*/
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

/**stack size 初始化为0,VM可会忽略*/
private final long stackSize;

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

/** 生成tid For generating thread ID */
private static long threadSeqNumber;

/** 当前线程状态*/
private volatile int threadStatus;

/** 中断状态使用 用于NIO操作中断*/
private volatile Interruptible blocker;
/**设置中断状态 锁监视器 防止线程阻塞在I/O操作*/
private final Object blockerLock = new Object();

// 特殊设置的为捕捉异常处理器 需要设置null unless explicitly set
private volatile UncaughtExceptionHandler uncaughtExceptionHandler;

// 默认的未捕捉异常处理器 需要设置 null unless explicitly set
private static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;

Thread方法:

yield:

/**尝试暗示调度器当前线程可以让出处理器,用于测试或者重现静态条件错误,也可用于设计并发控制*/
public static native void yield()

sleep:

/**
*停止当前线程执行去休眠
*不会失去已有的监视器(does not lose ownership of any monitors)
*当前线程被别的线程中断时抛出异常并清楚中断状态
*/
public static native void sleep(long millis) throws InterruptedException;

new:

/**
*创建一个新的线程
*ThreadGroup线程所属组(无用)
*target 目标执行任务
*name 线程名称
*stackSize 栈大小
*acc :AccessControlContext 访问控制上下文
*inheritThreadLocals: boolean 是否可以继承此线程的父线程(即创建这个线程的运行线程 parent = currentThread())的 inheritThreadLocalMap
*/
private Thread(ThreadGroup g, Runnable target, String name,
                   long stackSize, AccessControlContext acc,
                   boolean inheritThreadLocals)

start:

/**
*启动此线程,JVM将调用此线程的Run()方法
*结果将是两个线程并行,一个调用start()方法的线程,一个调用此线程Run()方法的线程
*一个线程只能start一次(否则:IllegalThreadStateException),一个线程一旦完成,可能不会再重新启动
*/
public synchronized void start()

run:

/**
*run方法:如果有目标Runnable将执行,也可重写此方法
*/
public void run() 
        if (target != null) 
            target.run();
        
    

exit:

/**
*由系统调用,提供实际退出前的清理机会
*/
private void exit()

stop:

/**
*强制停止线程执行
*放弃说有监视器(stop causes it to unlock all of the monitors that it has locked )
*已废弃
*/

public final void stop()

interrupt:

/**
*中断此线程,如果非当前线程中断自己,将进行访问检查
*如果线程阻塞在:Object.wait()、wait(long)、wait(long,int) 或者
*　　　　　　　Thread.join()、join(long)、jion(long,int)、sleep(long),sleep(long,int)
*　　　　　　　线程的中断状态将被清除,并且收到一个InterruptedException
*如果线程阻塞在:NIO的InterruptibleChannel 的I/O操作上
*　　　　　　　　线程的中断状态将被设置,并且收到一个ClosedByinterrupException
*如果线程阻塞在:NIO的Selector上
*　　　　　　　　线程的中断状态将被设置,并返回
*如果以上条件都不成立,那么线程中断状态将被设置
*/
    public void interrupt() 
        if (this != Thread.currentThread()) 
            checkAccess();
            // thread may be blocked in an I/O operation 线程可能阻塞在I/O
            synchronized (blockerLock) 
                Interruptible b = blocker;
                if (b != null) 
                    interrupt0();  // set interrupt status
                    b.interrupt(this);
                    return;
                
            
        
        // set interrupt status native 方法设置中断状态
        interrupt0();
    

static interrupted

/**
*清除线程中断状态,并返回清除前的线程中断状态
*/
public static boolean interrupted() 
        return currentThread().isInterrupted(true);
    

isInteruupted

/**
*测试当前线程中断状态
*/
public boolean isInterrupted() 
        return isInterrupted(false);
    

isAlive

/**
*线程已经启动并且还未死亡时为存活状态
*/
public final native boolean isAlive()

suspend

/**
*线程挂起 已废弃,容易引发死锁
*/
public final void suspend() 
        checkAccess();
        suspend0();
    

resume

/**
*恢复线程 已废弃,与挂起方法结合,容易死锁
*/
public final void resume() 
        checkAccess();
        resume0();
    

setPriority

/**
*设置线程优先级
*访问检查与参数校验
*设置优先级为min(group.max,newPrioritr)
*/
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);
        
    

getPriority

/**
*返回优先级
*/
public final int getPriority() 
        return priority;
    

setName

/**
*设置线程名称
*/
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);
        
    

getName

/**
*获取线程名称
*/
public final String getName() 
        return name;
    

join

/**
*使用循 环调用 Object.wait(long) 实现(阻塞方法调用线程,等待此线程对象运行结束),条件:当线程存活的时候
*millis = 0 意味着一直等待
*不建议在线程上使用Object.notify、notifyAll,这样会唤醒此方法再次进入循环判断
*tips:synchronized 获取shis监视器,后续调用Object.wait需要
*/
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) //判断是否带有超时时间.为0则为一直等待
            while (isAlive()) //线程未结束则一直等待
                wait(0);//调用Object.wati方法实现阻塞
            
         else 
            while (isAlive()) //等待超时结束
                long delay = millis - now;
                if (delay <= 0) //防止中途被notify
                    break;//等待时间结束
                
                wait(delay);//等待
                now = System.currentTimeMillis() - base;
            
        
    

/**
*参见上面方法
*/
public final void join() throws InterruptedException 
    join(0);

setDaemon

/**
*标记此线程为守护线程或用户线程,如果线程已经启动则:IllegalThreadStateException
*当只有守护线程时候,虚拟机退出
*/
    public final void setDaemon(boolean on) 
        checkAccess();
        if (isAlive()) 
            throw new IllegalThreadStateException();
        
        daemon = on;
    

getDaemon

/**
*返回此线程是否为守护线程
*/
public final boolean isDaemon() 
        return daemon;
    

checkAccess

/**
*访问检查
*/
    public final void checkAccess() 
        SecurityManager security = System.getSecurityManager();
        if (security != null) 
            security.checkAccess(this);
        
    

toString

/**
*toString方法:Thread[name,priority‘,groupName‘]
*
*/
    public String toString() 
        ThreadGroup group = getThreadGroup();
        if (group != null) 
            return "Thread[" + getName() + "," + getPriority() + "," +
                           group.getName() + "]";
         else 
            return "Thread[" + getName() + "," + getPriority() + "," +
                            "" + "]";
        
    

getContextClassLoader

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

setcontextClassLoader

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

static holdsLock

/**
*断言当前线程是否持有某个对象的监视器
*/
public static native boolean holdsLock(Object obj);

getStackTrace

/**
*获取此线程的栈帧元素
*/
public StackTraceElement[] getStackTrace()

getAllStackTraces

/**
*获取所有的线程的栈帧元素
*/
     // check for getStackTrace permission
        SecurityManager security = System.getSecurityManager();
        if (security != null) 
            security.checkPermission(
                SecurityConstants.GET_STACK_TRACE_PERMISSION);
            security.checkPermission(
                SecurityConstants.MODIFY_THREADGROUP_PERMISSION);
        

        // Get a snapshot of the list of all threads
        Thread[] threads = getThreads();
        StackTraceElement[][] traces = dumpThreads(threads);
        Map<Thread, StackTraceElement[]> m = new HashMap<>(threads.length);
        for (int i = 0; i < threads.length; i++) 
            StackTraceElement[] stackTrace = traces[i];
            if (stackTrace != null) 
                m.put(threads[i], stackTrace);
            
            // else terminated so we don‘t put it in the map
        
        return m;
    

getId

/**
*返回tid
*/
public long getId() 
        return tid;
    

getState

/**
*获取此线程的状态
*/
public State getState() 
        // get current thread state
        return jdk.internal.misc.VM.toThreadState(threadStatus);
    

setDefaultuncaughtExceptionhandler

/**
*设置所有线程的默认未捕捉异常处理器
*/
public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) 
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) 
            sm.checkPermission(
                new RuntimePermission("setDefaultUncaughtExceptionHandler")
                    );
        

         defaultUncaughtExceptionHandler = eh;
     
//获取默认异常处理器

public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()
    return defaultUncaughtExceptionHandler;

//获取异常处理器

public UncaughtExceptionHandler getUncaughtExceptionHandler() 
    return uncaughtExceptionHandler != null ?
        uncaughtExceptionHandler : group;

//设置异常处理器

public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) 
    checkAccess();
    uncaughtExceptionHandler = eh;

//向处理程序发送异常

private void dispatchUncaughtException(Throwable e) 
    getUncaughtExceptionHandler().uncaughtException(this, e);