public class TestThread2 {
	public static void main(String[] args) {
		Thread thread = new Thread();
		thread.start();
		System.out.println(thread);                           // Thread[Thread-0,5,main]
		System.out.println(thread.getName());                 // Thread-0
		System.out.println(thread.getState());                // TERMINATED
		System.out.println(thread.currentThread());           // Thread[main,5,main]
		System.out.println(thread.currentThread().getName()); // main
		System.out.println(thread.activeCount());             // 1
		try {
//			thread.wait();
			thread.join();
			thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(thread.isAlive());                 // false
 		thread.run();
		thread.stop();
		thread.yield();
        thread.interrupt();
	}
}

public abstract void run();

public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0); // 这里用到了 nextThreadNum(),其实就是对线程进行自增编号
}
private static int threadInitNumber;                  // 该属性用来给匿名线程自动编号的
private static synchronized int nextThreadNum() {     // 这个方法上了同步锁
    return threadInitNumber++;
}

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
    // 层层调用啊,继续看
    init(g, target, name, stackSize, null);
}
private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
    if (name == null) {
        throw new NullPointerException("name cannot be null");
    }
    this.name = name;
    Thread parent = currentThread();                        // 注释说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();  // 归属security线程组
        }
        /* If the security doesn't have a strong opinion of the matter use the parent thread group. */
        if (g == null) {
            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();      // daemon用来判断是不是守护线程的,让它与父线程(正在执行的)相统一
    this.priority = parent.getPriority(); // 与父线程统一优先权
    if (security == null || isCCLOverridden(parent.getClass()))
        this.contextClassLoader = parent.getContextClassLoader(); // 类装载器
    else
        this.contextClassLoader = parent.contextClassLoader;
    // 上下文访问控制,默认构造器过来的话是null
    this.inheritedAccessControlContext = acc != null ? acc : AccessController.getContext();
    this.target = target;   // 运行的目标对象。默认构造器过来的话是null
    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; // 堆栈大小。默认构造器过来是 0
    /* Set thread ID */
    tid = nextThreadID(); // 线程 id。nextThreadID()内部id自增
}

/*
 * 先列出run方法的源码
 * 官方注释：如果一个线程使用单独的 Runnable 运行对象构成的,那么Runnable对象的run方法会被调用。否则,这个方法不会做任何事。
 */
@Override
public void run() {
    if (target != null) {
        target.run();
    }
}
/*
 * run 方法的注释没有明确说要通过直接调用该方法才能启动线程,注释的潜台词是线程运行时自动调用run方法？？？
 * 还是先看看start方法源码以及注释再做判断吧
 * start方法注释第一句就是 该方法让线程开始执行,java 虚拟机调用该线程的run方法！！！
 * 调用该方法的后果是两个线程同时运行。
 * 一个线程一旦被执行就不能重启。
 */
public synchronized void start() {
    /**
     * 该方法不被主线程以及 “system” 线程组通过 VM 创建或设置来调用
     * 0 对应状态 NEW
     */
    if (threadStatus != 0)
        throw new IllegalThreadStateException(); // 任何一个线程在调用start前它的状态都应该是0,否则抛异常
    /* 
     * 通知线程组这个线程即将启动,这个线程可以被加进该组的线程列表并且线程组未启动的数量相应减少
     * 我把add()列到下面
     */
    group.add(this);
    boolean started = false;
    try {
        start0();  // 这个方法很奇怪,我在下面列出来
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this); // 启动失败的话,将该线程从线程组中移除,并且未启动的线程数加1
            }
        } catch (Throwable ignore) {
        }
    }
}
/*
 * 我刚刚说 start0 这个方法很奇怪,就是因为没有方法体,不知道它是怎么实现的。
 * 但是,仔细观察方法修饰符中有一个 native,特地上网百度了下才知道：
 * native关键字说明其修饰的方法是一个原生态方法,方法对应的实现不是在当前文件,而是在用其他语言(如C和C++)实现的文件中。
 * Java语言本身不能对操作系统底层进行访问和操作,但是可以通过JNI接口调用其他语言来实现对底层的访问。
 * JNI是Java本机接口(Java Native Interface),是一个本机编程接口,它是Java软件开发工具箱(java Software Development Kit, SDK)的一部分。
 * JNI允许Java代码使用以其他语言编写的代码和代码库。Invocation API(JNI的一部分)可以用来将Java虚拟机(JVM)嵌入到本机应用程序中,
 * 从而允许程序员从本机代码内部调用Java代码。
 */
private native void start0();
// ThreadGroup.class
void add(Thread t) {
    synchronized (this) {
        if (destroyed) {
            throw new IllegalThreadStateException();
        }
        if (threads == null) {
            threads = new Thread[4];
        } else if (nthreads == threads.length) {
            threads = Arrays.copyOf(threads, nthreads * 2); // 这里其实对线程组扩大长度为原来的2倍
        }
        threads[nthreads] = t; // 把线程加进去
            nthreads++;  // 线程数加1
            nUnstartedThreads--; // 未启动的线程数减少
    }
}

public class TestRunStart extends Thread {
	public static void main(String[] args) {
		TestRunStart testRunStart = new TestRunStart();
		testRunStart.run();
		testRunStart.start();
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName() + " is running!");
	}
}
// 打印输出
main is running!
Thread-0 is running!

public final void join() throws InterruptedException {
    join(0); // 继续调用
}
/*
 * 这个方法核心部分是调用了wait()方法,没大看懂什么意思,就为了等待？
 * 看看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) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}
// Object.class
// 操蛋啊,看不了。。。百度吧
public final native void wait(long timeout) throws InterruptedException;

/*
 * 唤醒正在该对象监视器上等待的单个线程。如果该对象上有多个线程在等待,其中一个会被唤醒。
 * 对于多个线程等待唤醒的情况下,会任意选择一个唤醒。
 * 调用任何一种 wait 方法都能使对象监视器上的一个线程进入等待状态。
 * 被唤醒的线程不能继续运行直到当前线程交出对象上的锁。
 * 被唤醒的线程将会和该对象上其它活跃的线程竞争对象锁。
 * 举个例子,唤醒线程在下一个线程锁住该对象时没有可靠的优劣势。
 * 该方法只能被拥有当前对象监视器的线程调用。
 * 线程成为对象监视器的主人只有三种方法：
 * 1.通过执行该对象 synchronized 实例方法
 * 2.通过执行该对象 synchronized 代码块
 * 3.对象是类的话,通过执行类的 synchronized 静态方法
 *
 * 一段时间内只有一个线程能拥有对象的监视器。
 */
public final native void notify();

public class TestWaitNotify {
	public static void main(String[] args) {
		ThreadA threadA = new ThreadA("threadA");
		ThreadB threadB = new ThreadB("threadB");
		threadA.start();
		synchronized (threadA) {
			try {
				long start = System.currentTimeMillis();
				threadA.wait(3000);
				long end = System.currentTimeMillis();
				System.out.println(Thread.currentThread().getName() + " wait " + (end - start));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		threadB.start();
	}
}
class ThreadA extends Thread {
	public ThreadA(String name) {
		super(name);
	}
	public void run() {
		synchronized (this) {
			System.out.println(Thread.currentThread().getName() + " is running...");
			try {
				long start = System.currentTimeMillis();
				wait(5000);
				long end = System.currentTimeMillis();
				System.out.println(Thread.currentThread().getName() + " wait " + (end - start));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
class ThreadB extends Thread {
	public ThreadB(String name) {
		super(name);
	}
	public void run() {
		synchronized (this) {
			System.out.println(Thread.currentThread().getName() + " is running...");
			long start = System.currentTimeMillis();
			notify();
			long end = System.currentTimeMillis();
			System.out.println(Thread.currentThread().getName() + " notify " + (end - start));
		}
	}
}
// 某次打印输出
threadA is running... // 3s后才开始打印输出第二行及以下内容
main wait 3001
threadB is running...
threadB notify 0      // 2s后才开始打印输出最后一行内容
threadA wait 5000

synchronized (threadA) {
	try {
		long start = System.currentTimeMillis();
		threadA.wait(3000);
		long end = System.currentTimeMillis();
		System.out.println(Thread.currentThread().getName() + " wait " + (end - start));
		threadA.notify();
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}
// 某一次打印输出
threadA is running...
main wait 3000
threadA wait 3000
threadB is running...
threadB notify 0

// main
public static void main(String[] args) {
	ThreadA threadA = new ThreadA("threadA");
	ThreadB threadB = new ThreadB(threadA);
	threadA.start();
	synchronized (threadA) {
		try {
			long start = System.currentTimeMillis();
			threadA.wait(3000);
			long end = System.currentTimeMillis();
			System.out.println(Thread.currentThread().getName() + " wait " + (end - start));
			threadB.start();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
		
}
// ThreadB.class
class ThreadB extends Thread {
	ThreadA threadA;
	public ThreadB(ThreadA threadA) {
		super(threadA);
		this.threadA = threadA;
	}
	public void run() {
		synchronized (threadA) {
			System.out.println(Thread.currentThread().getName() + " is running...");
			long start = System.currentTimeMillis();
			threadA.notify();
			long end = System.currentTimeMillis();
			System.out.println(Thread.currentThread().getName() + " notify " + (end - start));
		}
	}
}
// 某一次打印
threadA is running...
main wait 3000
Thread-0 is running...
Thread-0 notify 0
threadA wait 3001

/*
 * 让当前执行的线程休眠,暂时停止运行指定的毫秒数。
 * 受系统定时器和调度器精度的影响。
 * 线程不会丢失任何监视器的所有权。和wait()不同,wait()会让出所有权
 */
public static native void sleep(long millis) throws InterruptedException;

public class TestSleep {
	public static void main(String[] args) {
		ThreadC threadC = new ThreadC("threadC");
		threadC.start();
	}
}
class ThreadC extends Thread {
	public ThreadC(String name) {
		super(name);
	}
	public synchronized void run() {
		try {
			for(int i = 0; i < 10; i++) {
				System.out.printf("%s: %d\n", this.getName(), i);
				// i 能被4整除时,休眠2000毫秒
				if(i % 4 == 0) {
					Thread.sleep(2000);
				}
			}
		} catch (InterruptedException  e) {
			e.printStackTrace();
		}
	}
}

/*
 * 提示调度器当前线程能够做出让步,但是调度器可以忽略这个提示。
 * 让步是一种尝试,以改善线程之间的相对进展,否则将过度利用CPU。
 * 不怎么用,很少合适
 * 在设计并发控制结构时,也可能是有用的,例如在 java.util.concurrent.locks 包
 */
public static native void yield();

public class TestYield {
	public static void main(String[] args) {
		ThreadD threadD = new ThreadD("threadD");
		ThreadD threadD2 = new ThreadD("threadD2");
		threadD.start();
		threadD2.start();
	}
}
class ThreadD extends Thread {
	public ThreadD(String name) {
		super(name);
	}
	public synchronized void run() {
		for(int i = 0; i < 5; i++) {
			System.out.printf("%s [%d]:%d\n", this.getName(), this.getPriority(), i);
			// i整除2时，调用yield
			if(i % 2 == 0) {
				Thread.yield();
			}
		}
	}
}
// 某次打印
threadD2 [5]:0
threadD [5]:0
threadD2 [5]:1
threadD2 [5]:2
threadD [5]:1
threadD [5]:2
threadD2 [5]:3
threadD2 [5]:4
threadD [5]:3
threadD [5]:4

private volatile Interruptible blocker;
private final Object blockerLock = new Object();
/*
 * 中断线程自己,总是允许的。
 * 如果线程调用了 wait,join,sleep方法进入阻塞状态,然后调用该方法会报 InterruptedException
 * 如果线程在 java.nio.channels.InterruptibleChannel 上操作 I/O 被阻塞,通道会被关闭,
 * 设置线程的中断状态并且线程会收到 java.nio.channels.ClosedByInterruptException
 * 如果线程在 java.nio.channels.Selector 上被阻塞,设置中断状态并且立即从选择操作中 可能 返回一个 非0 值,
 * 仅仅作为 java.nio.channels.Selector#wakeup 方法被调用的返回值。
 * 如果没有上述条件,那么会立即设置中断状态。
 * 中断死亡的线程没有任何效果。
 */
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);      // 在 Interruptible包里,看不到源码
            return;
        }
    }
    interrupt0(); // native 修饰的,看不到源码
}

public class TestInterrupt {
	public static void main(String[] args) throws Exception {
		Runnable runnable = new Runnable() {
			@Override
			public void run() {
				while (true) {
					if(Thread.currentThread().isInterrupted()) {
						System.out.println("线程被中断了");
						return;
					} else {
						System.out.println("线程没有被中断");
					}			
				}
			}
		};
		Thread thread = new Thread(runnable);
		long start = System.currentTimeMillis();
		thread.start();
		Thread.sleep(3000);
		thread.interrupt();
		System.out.println("线程中断了,程序到这里了");
		long end = System.currentTimeMillis();
		System.out.println(end - start);	
	}	
}
// 打印输出
...
线程没有被中断
线程没有被中断
线程中断了,程序到这里了
线程被中断了
3000