wait|notify|notifyAll|sleep|volatile

最近研究下多线程的基础知识，实际项目中也很少用到多线程方面的知识，几乎都忘了。为了以后更好的跳槽，回顾一下。

先从问题开始，以前面试经常遇到线程的问题一个线程加1，另一个线程减1，交替执行，以前只是写伪代码，就是wait 和 notify，但是不明白其中的道理，今天彻底琢磨了一下，调试了一下 可以跑

public class MyThread implements Runnable
{
	private int num = 0;
	private Object object = new Object();
	private int flag = 1;
	@Override
	public void run()
	{
		inc();
	}

	public void inc()
	{
		synchronized (object)
		{
			try
			{
				while (flag == 1)
				{
					System.out.println(Thread.currentThread().getName() + "获得object锁！");
					System.out.println(Thread.currentThread().getName() + " sleep");
					Thread.currentThread().sleep(1500);
					object.notify();
					flag = 0;
					num++;
					System.out.println(Thread.currentThread().getName() + " num：" + num);
					object.wait();

				}
			} catch (Exception e)
			{
				e.printStackTrace();
			}

			try
			{
				while (flag == 0)
				{
					System.out.println(Thread.currentThread().getName() + "获得object锁！");
					flag = 1;
					num--;
					System.out.println(Thread.currentThread().getName() + " num：" + this.num);
					object.notify();
					object.wait();
				}
			} catch (InterruptedException e)
			{
				e.printStackTrace();
			}

		}
	}

	public static void main(String[] args)
	{
		MyThread myThread = new MyThread();
		Thread incThread = new Thread(myThread, "inc");
		incThread.start();
		Thread decThread = new Thread(myThread, "dec");
		decThread.start();
	}
}

总结：

1. 调试过程中总会遇到 java.lang.IllegalMonitorStateException，原因是未获得对象的锁就对对象操作！

2. 执行wait, notify时，必须获得该对象的锁，是因为wait|notify有可能产生竟态条件（race condition）

wait：

在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。

当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。

对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用：

synchronized (obj)

{

while (true)

{

obj.wait();

// Perform action appropriate to condition

}

}

此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。

notify：
唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个wait 方法，在对象的监视器上等待。
直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。
此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，线程可以成为此对象监视器的所有者：

• 通过执行此对象的同步实例方法。

• 通过执行在此对象上进行同步的 synchronized 语句的正文。

• 对于 Class 类型的对象，可以通过执行该类的同步静态方法。

一次只能有一个线程拥有对象的监视器。

notifyAll：

唤醒在此对象监视器上等待的所有线程。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。

此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。

sleep：

Thread 线程类的方法，以上都是Object基类的方法。调用此方法主要暂停执行，不会释放锁，wait释放锁，主要用于线程之间的交互。

volatile：

作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值.

public class TestVolatile
{
	private volatile static int count = 0;

	public static void inc()
	{
		try
		{
			Thread.currentThread().sleep(1000);
		} catch (InterruptedException e)
		{
			e.printStackTrace();
		}

		TestVolatile.count++;
		if(TestVolatile.count == 1000) {
			System.out.println(count);
		}
	}

	public static void main(String[] args)
	{
		for (int i = 0; i < 1000; i++)
		{
			new Thread(new Runnable()
			{
				public void run()
				{
					TestVolatile.inc();
				}
			}).start();
		}
	}
}

最终的值不一定是1000，多线程可能同时获得同一值。其中一个县城+1，修改主存中的volatile值，而另一个线程+1 写回主存中就会造成数据错误。