（新手）java多线程基础知识——调度与同步

以前写过一篇关于多线程的总结：
http://kyfxbl.iteye.com/blog/1370377

很久没用到，忘记了。最近又遇到了一些多线程的问题，重新查了些资料，再提炼一下。本文不涉及java.util.concurrent包里的API，后面再专门介绍

1、线程的状态

线程的运行状态主要有runnable、running、waiting、timed_waiting、blocked等，主要有2类API，可以控制线程的运行状态

第一类是调度类，不涉及object monitor和synchronized方法，这类API包括yield()、sleep()、join()等

第二类是同步类，涉及到object monitor和synchronized方法，这类API包括wait()、notify()、notifyAll()

总的来说，第一类API比第二类要简单

2、调度类API

这类API不涉及同步方法，是直接控制线程的运行状态，都是Thread类定义的方法

yield()会使线程从running状态切换到runnable状态，但是也有可能JVM立刻又把该线程切换回running状态（优先级高、无其他线程等原因），可以说，这个方法只是“建议”jvm先去执行其他线程，运行结果是不能保证的

sleep()需要跟一个参数，单位是毫秒，会使线程进入timed_waiting状态，sleep时间结束以后，会回到runnable状态

join()使当前线程进入waiting状态，等join的线程执行完毕之后，才回到runnable状态。举例来说，有2个线程t1和t2，在t1里执行了t2.join()，则t1进入waiting状态，等t2执行完毕之后，t1才回到runnable状态

public static void main(String[] args) throws InterruptedException {

		final Thread thread = new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					Thread.sleep(10000);// 此行代码使该线程进入timed_waiting状态
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}

		});

		thread.start();

		new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					thread.join();// 此行代码使该线程进入waiting状态，等待thread执行完毕
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}

		}).start();

	}

用jstack看到这2个线程的状态：



Thread-0由于执行了sleep()方法，而进入timed_waiting状态；Thread-1由于执行了join()方法，而进入waiting状态

调度类的API不涉及synchronized方法，所以也不涉及到blocked状态

3、synchronized关键字与object monitor

同步的关键字是synchronized，其实我觉得叫“锁定”会比较好，不知道怎么理解“同步”这个词

synchronized方法包括2种，一种是标注了synchronized关键字的方法，一种是synchronized代码块

本质上差不多，只要是同步方法，都有一个object monitor：对于synchronized关键字方法来说，monitor就是该方法所属的类的实例；对于synchronized代码块来说，monitor是在synchronized关键字后面直接指定的

当线程执行到同步方法或者同步代码块的时候，就会获取object monitor，并继续执行；但是，同一时刻，只有唯一一个线程可以获取object monitor，其他的线程就会阻塞，进入blocked状态，等待持有object monitor的那个线程释放object monitor

这就是同步代码的基本状况，如果没有同步类的API的话，多线程执行就无法控制了，只能线程A获取->线程A释放->线程B获取->线程B释放->线程C获取……，这样顺序执行下去，所以就有了下面的同步类API

4、同步类API

前面说到了，同步的代码（方法或代码块），都有一个object monitor，可以通过在object monitor上执行wait()、notify()、notifyAll()方法，来进行多线程之间的通信

在object monitor上执行wait()方法，会使当前的线程释放锁，并进入waiting状态；并将该线程加入object monitor内部的“等待线程列表”中

在object monitor上执行notify()方法，会从“等待线程列表”中随机挑选一个线程唤醒，进入runnable状态（如果没有获取object monitor，则会立刻进入blocked状态）

在object monitor上执行notifyAll()方法，会将“等待线程列表”中所有的线程都唤醒，全部进入runnable状态（但是随后没有获取object monitor的线程，会立刻进入blocked状态）

注意，当一个线程调用了object.wait()方法进入waiting状态之后，如果没有其他线程帮它调用object.notify()方法，则该线程将永远停留在waiting状态，此线程永不结束

贴一段示例代码进行说明：

public static void main(String[] args) {

		final Object o = new Object();

		new Thread(new Runnable() {

			@Override
			public void run() {
				synchronized (o) {
					try {
						System.out.println("me first");// 这个线程先执行，是期望的结果，但是不能保证
						Thread.sleep(15000);
						o.wait();
						System.out.println("wake up and done");
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}

		}).start();

		new Thread(new Runnable() {

			@Override
			public void run() {
				synchronized (o) {
					try {
						System.out.println("it's my time");// 如果这个线程先执行，则另一个线程将永远waiting
						Thread.sleep(15000);
						o.notify();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}

		}).start();

	}

阶段1：thread-0进入timed_waiting状态，thread-1没有获取到object monitor，进入blocked状态



控制台输出：me first

阶段2：thread-0调用了o.wait()方法，释放锁并进入waiting状态；thread-1执行sleep()方法，进入timed_waiting状态



控制台输出：it's my time

阶段3：thread-1执行o.notify()方法，唤醒thread-0，自己运行结束，释放锁（并不是notify方法释放了锁）；thread-0执行最后一行代码，然后也结束；两个线程都执行完毕

控制台输出：wake up and done

但是，这里有很强的随机性，每次执行的效果是不同的！如果是thread-1先执行的话，那么当thread-0调用o.wait()之后，就会永远停留在waiting状态，该线程永远不会结束

5、同步类API的限制

上述3个方法，都是只能在synchronized代码里调用的，否则就会报错。也就是说，虽然这3个方法都是Object类定义的方法，但是只有成为object monitor的实例才能调用

比如以下这段代码是不能执行的，o是object monitor，而o1不是，所以不能调用o1.wait()：

public static void main(String[] args) {

		final Object o = new Object();

		final Object o1 = new Object();

		new Thread(new Runnable() {

			@Override
			public void run() {

				synchronized (o) {
					try {
						o1.wait();// 错误
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}

			}

		}).start();

	}

6、总结

yield()、sleep()、join()都是Thread类定义的方法，不涉及同步方法，因此也不会使线程切换到blocked状态，也不涉及object monitor的释放

wait()、notify()、notifyAll()是Object类定义的方法，但是只能在object monitor实例上调用

wait()方法会立刻释放object monitor，并使当前线程进入waiting状态

notify()和notifyAll()方法只是唤醒此前调用了wait()方法的线程，但是自己并不会释放锁

本文也参考了：
http://dylanxu.iteye.com/blog/1322066

yield()方法Java没有规定必须要实现，因此某些虚拟机可能不会实现该方法。楼主关于wait和notify方法的代码是错误的。

不错的文章！最近工作中频繁用到了多线程的知识，看了楼主的文章等于又帮我梳理了一遍，非常感谢！

哪里错？实际运行结果都贴出来了

多线程的悲剧就在于，即使结果出来了也不能证明代码是对的。你看一下wait方法的描述。多线程容易让人误入歧途的地方就在于正确的测试结果会加强对错误做法的认同。

我知道你的意思，已经在注释里写了，运行的结果是随机的


这段代码是为了演示wait()方法的作用，不是为了实现某个功能

每天收集一点java知识,学点多线程还是蛮重要的,现在什么都是多线程.知识梳理很详细,谢谢总结

你想让第一个线程先启动，就先start 然后在main上sleep一段时间再起第二呗

而且一般讲 wait notify 都是

在这样的情况

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout);
         ... // Perform action appropriate to condition
     }