Thread源码理解

1.首先看一下Runnable接口，只有一个run方法。   

    Thread方法继承Runnable接口。

package java.lang;
public interface Runnable {
    public abstract void run();
}

2.看一下Thread实现的run()方法。

//target 为传入线程的对象
private Runnable target;
public void run() {
	if (target != null) {
	    target.run();
	}
}

//这个就是target的来源。
public Thread(Runnable target) {
	init(null, target, "Thread-" + nextThreadNum(), 0);
}

 3.构造函数

    在构造函数之前，Thread类中还有一个静态的代码块，这个是Object的方法，这里应该是重写了。

 private static native void registerNatives();
    static {
        registerNatives();
    }

 

private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
        //返回当前执行的线程。
        Thread parent = currentThread();
        //安全管理，查看线程拥有的功能（例如：读写文件，访问网络）。
        SecurityManager security = System.getSecurityManager();
        //g这个变量是线程组
        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);
	    }
	}
        //记录一个线程到线程组里，好像只是取得一个线程号。
        g.addUnstarted();
	this.group = g;
        //线程是否为守护线程
        this.daemon = parent.isDaemon();
        //线程的优先级
        this.priority = parent.getPriority();
	//线程名字
	this.name = name.toCharArray();
	if (security == null || isCCLOverridden(parent.getClass()))
            //似乎是一个加载器，加载类或者资源的东西
            this.contextClassLoader = parent.getContextClassLoader();
	else
	    this.contextClassLoader = parent.contextClassLoader;
       //快照？权限的快照
	this.inheritedAccessControlContext = AccessController.getContext();
	this.target = target;
       //更改线程的优先级。
       setPriority(priority);
        if (parent.inheritableThreadLocals != null)
        //本地现成创建
        this.inheritableThreadLocals =
		ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        //栈的大小
       this.stackSize = stackSize;
       //线程id，并且+1
        tid = nextThreadID();
    }

4.线程的名字相关方法

//存线程的名字的数组，这里面没用String。看来char[]的效率会高一点.
private char	name[];
//线程的编号，没有赋初值，所以从0开始。静态的。


private static int threadInitNumber;

public final String getName() {
	return String.valueOf(name);
}

public final void setName(String name) {
        //判定当前运行的线程是否有权修改该线程.(意思好像是主线程能不能修改当前线程？？)
	checkAccess();
	this.name = name.toCharArray();
}

//判定当前运行的线程是否有权修改该线程.
public final void checkAccess() {
	SecurityManager security = System.getSecurityManager();
	if (security != null) {
	    security.checkAccess(this);
	}
}
//这个是初始化线程的操作，名字默认Thread-0 Thread-1
public Thread() {
	init(null, null, "Thread-" + nextThreadNum(), 0);
}
//带参的构造函数，只是给线程起了个名字。
public Thread(String name) {
	init(null, null, name, 0);
}

//同步获取线程编号，并+1
private static synchronized int nextThreadNum() {
	return threadInitNumber++;
}

 还有在线程运行的时候还能改线程名字，并且各个线程的名字可以一样，用线程组管理的。

 

5.start方法。

//线程状态
private int threadStatus = 0;
//线程自己停止，还是用stop()停止线程的。默认值为false;
private boolean stopBeforeStart; 

public synchronized void start() {
       //重复start()会报错
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        //线程组添加这个线程。
        group.add(this);
        start0();
        if (stopBeforeStart) {
	    stop0(throwableFromStop);
	}
}

private native void start0();

private native void stop0(Object o);

 

几个等待的操作

6.yield()，释放

暂停当前正在执行的线程对象，并执行其他线程。只是暂停一下。

 public static native void yield();

7.sleep() 睡

 public static native void sleep(long millis) throws InterruptedException;

    sleep，很无耻的一个，纳秒功能形同虚设。

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");
	}
        //就是纳秒大于500000 ，即大于0.5毫秒的时候四舍五入。或者毫秒为0、纳秒不为0时，睡一微秒。
	if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
	    millis++;
	}
	sleep(millis);
}

 

8.interrupt()

    中断线程。

 private Object blockerLock = new Object();

void blockedOn(Interruptible b) {
	synchronized (blockerLock) {
	    blocker = b;
	}
}


public void interrupt() {
	if (this != Thread.currentThread())
	    checkAccess();

	synchronized (blockerLock) {
	    Interruptible b = blocker;
	    if (b != null) {
		interrupt0();		// 只改一个flag？
		b.interrupt();
		return;
	    }
	}
	interrupt0();
}

private native void interrupt0();

 

使用起来很简单，直接使用t.interrupt(),即停止，但是如果停止时线程内部抛出异常的时候，线程内部还要进行一次this.interrupt()

9.Object中的notify()和wait()

    等待。

 public final void wait() throws InterruptedException {
	wait(0);
}

public final native void wait(long timeout) throws InterruptedException;

    唤醒在此对象监视器上等待的单个线程

public final native void notify();
 public final native void notifyAll();

源码没有什么价值。都是native方法。

sleep()使当前线程进入停滞状态，停止固定时间，然后等待运行。
yield()只是使当前线程停一下，重新等待运行
wait()后，线程会释放掉它所占有的“锁标志”， 对应notify。

10.stop

//线程状态，0标识未启动。
  private int threadStatus = 0;


@Deprecated
    public final synchronized void stop(Throwable obj) {
	stop1(obj);
    }

    private final synchronized void stop1(Throwable th) {
        //获得当前线程
        SecurityManager security = System.getSecurityManager();
	if (security != null) {
            //检查权限
	    checkAccess();
	    if ((this != Thread.currentThread()) ||
		(!(th instanceof ThreadDeath))) {
		security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);
	    }
	}
	if (threadStatus != 0) {
           //挂起线程
            resume(); 
	    stop0(th);
	} else {
	    if (th == null) {
	 	throw new NullPointerException();
	    }
            //设置为手动关闭状态。非自己运行完。
            stopBeforeStart = true;
            //异常对象。不知道是干什么的。
	    throwableFromStop = th;
        }
    }

    private native void stop0(Object o); 

11.isAlive()

    又是一个native方法。

    public final native boolean isAlive();

12.优先级有关方法

//最小权限
public final static int MIN_PRIORITY = 1;
//普通权限
public final static int NORM_PRIORITY = 5;
//最大权限
public final static int MAX_PRIORITY = 10;

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

public final int getPriority() {
	return priority;
}

 private native void setPriority0(int newPriority);

//toString方法中有优先级的输出。

13.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;
	    }
	}
    }

  总结：没看懂。倒是很好奇native里面写的是什么。