说明
对于JDK源码分析的文章，仅仅记录我认为重要的地方。源码的细节实在太多，不可能面面俱到地写清每个逻辑。所以我的JDK源码分析，着重在JDK的体系架构层面，具体源码可以参考：http://www.cnblogs.com/skywang12345/category/455711.html。
实现多线程的两种方式
- Thread
- Runnable
优先使用 Runnable
因为 Thread 是类，一个类只能有一个父类，但是可以有多个接口。Runnable 有更好的扩展性。
Runnable 还可以用于“资源的共享”，如果多个线程是基于同一个 Runnable 对象建立的，它们会共享 Runnable 对象上的资源。
start() 和 run()的区别说明
- start: 启动一个新的线程，新线程调用 run 方法。start
不能重复调用。 - run：和普通方法一样，可以重复调用。但是并
不会启动新线程。
测试代码
public class jdk {
public static class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running.");
}
}
public static void main(String[] args) {
Thread thread = new MyThread("myThread");
System.out.println(Thread.currentThread().getName()+" call mythread.run()");
thread.run();
System.out.println(Thread.currentThread().getName()+" call mythread.start()");
thread.start();
}
}
输出：
main call mythread.run()
main is running
main call mythread.start()
mythread is running
分析：
在main中，直接调用thread.run()时，仅仅是调用了MyThread实例的run()方法，并没有新建线程。所以run()方法中的Thread.currentThread().getName()，仍是main()！
而在调用thread.start()后，就会启动新的MyThread线程，并调用其中的run()方法，此时Thread.currentThread().getName()为新启动线程。
start 源码
public synchronized void start() {
// 如果线程不是"就绪状态"，则抛出异常！
if (threadStatus != 0)
throw new IllegalThreadStateException();
// 将线程添加到ThreadGroup中
group.add(this);
boolean started = false;
try {
// 通过start0()启动线程
start0();
// 设置started标记
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
run 源码
public void run() {
if (target != null) {
target.run();
}
}
wait(), notify(), notifyAll()
- wait()：让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)。
- wait(long timeout)：让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。
- notify()：唤醒在此对象监视器上等待的单个线程
- notifyAll()：唤醒在此对象监视器上等待的所有线程
notify()是依据什么唤醒等待线程的？或者说，wait()等待线程和notify()之间是通过什么关联起来的？
答案是：依据“对象的同步锁”。
多线程循环打印 ABC
思路：考察多线程间通信。首先需要一个线程共有的变量，来标识打印的状态。在 run 方法中，首先获取一个公共的对象，相当于是把「多线程变成顺序执行」，如果获取锁后，并不是需要打印的状态，就释放锁，进入等待；其它线程会得到锁，然后判断，如果是打印状态，就打印，然后通知所有线程，并释放锁。
public class PrintABC {
private static final int PRINT_A = 0;
private static final int PRINT_B = 1;
private static final int PRINT_C = 2;
private static class MyThread extends Thread {
int which; // 0：打印A；1：打印B；2：打印C
static volatile int state; // 线程共有，判断所有的打印状态
static final Object t = new Object();
public MyThread(int which) {
this.which = which;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (t) {
while (state % 3 != which) {
try {
t.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(toABC(which)); // 执行到这里，表明满足条件，打印
state++;
t.notifyAll(); // 调用notifyAll方法
}
}
}
}
public static void main(String[] args) {
new MyThread(PRINT_A).start();
new MyThread(PRINT_B).start();
new MyThread(PRINT_C).start();
}
private static char toABC(int which) {
return (char) ('A' + which);
}
}
yield
并不会释放锁！
sleep
让当前线程休眠，由“运行状态”→“阻塞状态”。并不会释放任何锁，到时间后线程会进入“就绪状态”。
测试代码
// SleepLockTest.java的源码
public class SleepLockTest{
private static Object obj = new Object();
public static void main(String[] args){
ThreadA t1 = new ThreadA("t1");
ThreadA t2 = new ThreadA("t2");
t1.start();
t2.start();
}
static class ThreadA extends Thread{
public ThreadA(String name){
super(name);
}
public void run(){
// 获取obj对象的同步锁
synchronized (obj) {
try {
for(int i=0; i <10; i++){
System.out.printf("%s: %d\n", this.getName(), i);
// i能被4整除时，休眠100毫秒
if (i%4 == 0)
Thread.sleep(100);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
输出的结果（t1 和 t2 的顺序不定，但是必定是同时执行0~9，因为 sleep 并没有释放锁）：
t1: 0
t1: 1
t1: 2
t1: 3
t1: 4
t1: 5
t1: 6
t1: 7
t1: 8
t1: 9
t2: 0
t2: 1
t2: 2
t2: 3
t2: 4
t2: 5
t2: 6
t2: 7
t2: 8
t2: 9
join
作用
让“主线程”等待“子线程”结束之后才能继续运行。
// 主线程
public class Father extends Thread {
public void run() {
Son s = new Son();
s.start();
s.join();
...
}
}
// 子线程
public class Son extends Thread {
public void run() {
...
}
}
在上述代码中，是 Father 线程，在 son 子线程运行结束后，再继续运行。
源码
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()) { // isAlive() 通过子线程调用，则判断的就是子线程
wait(0); // 等待的是当前线程（CPU 正则运行的线程），而不是子线程！
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
测试代码
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("MyThread start ...");
for (int i = 0; i < 1000000; i++) {
}
System.out.println("MyThread end ...");
}
}
@Test
public void testJoin() throws InterruptedException {
Thread thread = new MyThread();
thread.start();
thread.join();
System.out.println("testJoin end ...");
}
输出：
MyThread start ...
MyThread end ...
testJoin end ...
我们可以看到，调用了 join() 后，主线程输出的testJoin end ...是在MyThread end ...之后，这是因为main线程等待thread线程执行结束后，才继续执行。
问题：为什么在main中调用的thread.join()，却是main线程等待？
虽然是调用子线程的wait()方法，但是它是通过“主线程”去调用的；所以，休眠的是主线程，而不是“子线程”！
wait() 源码的注释：Causes the current thread to wait
用户线程 守护线程
- 用户线程：用户执行用户级任务
- 守护线程：“后台线程”，一般用来执行后台任务。
需要注意的是：Java虚拟机在“用户线程”都结束后会后退出。
问题：main() 方法，是守护线程？
答案：不是。main（）方法启动的是非守护线程，如果只有这个线程，在mian（）的最后一行代码，JVM 会退出（因为所有非守护进程都死了）。
验证代码：
public static void main(String[] args){
System.out.println(Thread.currentThread().getName());
System.out.println(Thread.currentThread().isDaemon());
}
输出：
main
false
JVM终止运行条件
当Java虚拟机启动时，通常有一个单一的非守护线程（该线程通过是通过main()方法启动）。JVM会一直运行直到下面的任意一个条件发生，JVM就会终止运行：
- 调用了exit()方法，并且exit()有权限被正常执行。
- 所有的“非守护线程”都死了(即JVM中仅仅只有“守护线程”)。
