从控制权开始讨论java线程的同步方案。

首先在java里同步有两种一种是使用同步synchronized(不知道我拼写对不对哈)，它的用法和lock用法一样，咱先归为一类。

 第二种是object类中的wait,notify,notifyall.

第一个知识点：线程的控制权问题

当调用wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其它synchronized数据可被别的线程使用

waite()和notify()因为会对对象的“锁标志”进行操作，所以它们必须在 synchronized函数或synchronized　block中进行调用。如果在non-synchronized函数或non- synchronized　block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。

以下是一个演示代码，以最简洁的方式说明复杂的问题：

/**以下是一个演示代码，以最简洁的方式说明复杂的问题：
 简要说明下：
 NotifyThread是用来模拟3秒钟后通知其他等待状态的线程的线程类；
 WaitThread是用来模拟等待的线程类；
 等待的中间对象是flag，一个String对象；
 main方法中同时启动一个Notify线程和三个wait线程；**/public class NotifyTest {
private String flag="true";

class NotifyThread extends Thread {
public NotifyThread(String name) {
super(name);
}

public void run() {
try {
sleep(3000);// 推迟3秒钟通知
} catch (InterruptedException e) {
e.printStackTrace();
}

flag="false";
flag.notify();
}
};

class WaitThread extends Thread {
public WaitThread(String name) {
super(name);
}

public void run() {
while (flag != "false") {
System.out.println(getName() + " begin waiting!");
long waitTime=System.currentTimeMillis();
try {
flag.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
waitTime=System.currentTimeMillis() - waitTime;
System.out.println("wait time :" + waitTime);
}
System.out.println(getName() + " end waiting!");

}
}

public static void main(String[] args) throws InterruptedException {
System.out.println("Main Thread Run!");
NotifyTest test=new NotifyTest();
NotifyThread notifyThread=test.new NotifyThread("notify01");
WaitThread waitThread01=test.new WaitThread("waiter01");
WaitThread waitThread02=test.new WaitThread("waiter02");
WaitThread waitThread03=test.new WaitThread("waiter03");
notifyThread.start();
waitThread01.start();
waitThread02.start();
waitThread03.start();
}

}
以上代码就演示了falg并非 synchronized，编译没问题，运行就报IllegalMonitorStateException.

这儿要非常注意的几个事实是

任何一个时刻，对象的控制权（monitor）只能被一个线程拥有。

无论是执行对象的wait、notify还是notifyAll方法，必须保证当前运行的线程取得了该对象的控制权（monitor）

如果在没有控制权的线程里执行对象的以上三种方法，就会报java.lang.IllegalMonitorStateException异常。

JVM基于多线程，默认情况下不能保证运行时线程的时序性

基于以上几点事实，我们需要确保让线程拥有对象的控制权。

也就是说在waitThread中执行wait方法时，要保证waitThread对flag有控制权；

在notifyThread中执行notify方法时，要保证notifyThread对flag有控制权。

线程取得控制权的方法有三：

执行对象的某个同步实例方法。

执行对象对应类的同步静态方法。

执行对该对象加同步锁的同步块。

 

第二个知识点：标题还没想好

从操作系统的角度讲，os会维护一个ready queue（就绪的线程队列）。并且在某一时刻cpu只为ready queue中位于队列头部的线程服务。

但是当前正在被服务的线程可能觉得cpu的服务质量不够好，于是提前退出，这就是yield。（jdk文档解释thread.yield() :暂停当前正在执行的线程对象，并执行其他线程。）

或者当前正在被服务的线程需要睡一会，醒来后继续被服务，这就是sleep。

Thread.sleep()与Thread.yield()的区别：

1：sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

2：sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；yield()只能使同优先级的线程有执行的机会。