一、Synchronized
synchronized中文解释是同步，那么什么是同步呢，解释就是程序中用于控制不同线程间操作发生相对顺序的机制，通俗来讲就是2点，第一要有多线程，第二当多个线程同时竞争某个资源的时候会有先后顺序。在java中有三种写synchronized的方式：
第一种：写在普通方法的前面，这种表示对实例对象加锁第二种：写在静态方法前面，这种表示对类对象加锁第三种：写在代码块中，锁是Synchonized括号里配置的对象（可能是实例对象，也可能是类对象）
总体说来就2种，一种就是锁实例对象，一种锁类对象。
锁实例对象就是当多个线程同时操作这个实例对象（针对的是特定的实例对象）的时候必须先获取锁，如果无法获取锁，则必须处于等待状态，而和锁类对象区别是，当多个线程同时操作的时候，任何以这个类对象实例化的对象都要获取锁才能操作。
看下面的例子：
public class Synchronized_Test {public static void main(String[] args){Thread t1=new Thread(new MyRunnable());Thread t2=new Thread(new MyRunnable());t1.start();t2.start();}}class MyRunnable implements Runnable{private synchronized void synchMethodTest(){for(int i=0;i<10;i++)System.out.println(Thread.currentThread().getName()+"synchMethodTest: "+i);}public void run() {synchMethodTest();}}
其输出结果为：
Thread-0synchMethodTest: 0Thread-1synchMethodTest: 0Thread-0synchMethodTest: 1Thread-1synchMethodTest: 1Thread-0synchMethodTest: 2Thread-1synchMethodTest: 2Thread-0synchMethodTest: 3Thread-1synchMethodTest: 3Thread-0synchMethodTest: 4Thread-1synchMethodTest: 4Thread-0synchMethodTest: 5Thread-1synchMethodTest: 5Thread-0synchMethodTest: 6Thread-1synchMethodTest: 6Thread-0synchMethodTest: 7Thread-1synchMethodTest: 7Thread-0synchMethodTest: 8Thread-1synchMethodTest: 8Thread-0synchMethodTest: 9Thread-1synchMethodTest: 9
因为synchronized是写在普通方法前，是对特定的实例对象加锁，t1，t2为两个不同的实例，
所以他们在执行synchronized方法时并不会互相阻塞对方。
如果将synchronized方法改成static方法，那么就是针对类对象加锁，任何以这个类对象实例化的对象都要获取锁才能操作，
t1，t2虽然是两个不同的实例，但都是同一个类对象的实例，所以当t1取得锁开始执行synchronized方法后，就会阻塞t2，
t2需要取得锁之后才能执行，如下：
public class Synchronized_Test {public static void main(String[] args){Thread t1=new Thread(new MyRunnable());Thread t2=new Thread(new MyRunnable());t1.start();t2.start();}}
class MyRunnable implements Runnable{private synchronized static void synchMethodTest(){for(int i=0;i<10;i++)System.out.println(Thread.currentThread().getName()+"synchMethodTest: "+i);}public void run() {synchMethodTest();}}
输出结果为：
Thread-0synchMethodTest: 0Thread-0synchMethodTest: 1Thread-0synchMethodTest: 2Thread-0synchMethodTest: 3Thread-0synchMethodTest: 4Thread-0synchMethodTest: 5Thread-0synchMethodTest: 6Thread-0synchMethodTest: 7Thread-0synchMethodTest: 8Thread-0synchMethodTest: 9Thread-1synchMethodTest: 0Thread-1synchMethodTest: 1Thread-1synchMethodTest: 2Thread-1synchMethodTest: 3Thread-1synchMethodTest: 4Thread-1synchMethodTest: 5Thread-1synchMethodTest: 6Thread-1synchMethodTest: 7Thread-1synchMethodTest: 8Thread-1synchMethodTest: 9
t1执行完成，释放synchronized锁后，t2才能执行。如果在代码块中对类对象也是一样：
class MyRunnable implements Runnable{private void synchMethodTest(){synchronized (MyRunnable.class){for(int i=0;i<10;i++)System.out.println(Thread.currentThread().getName()+"synchMethodTest: "+i);}}public void run() {synchMethodTest();}}
注意：
类方法中，synchronized锁住的是对象this,只有调用同一个对象的方法才需要获取锁。同时，
同一个对象中所有加了synchronize的方法只能一次调用一个；
静态方法中，synchronized锁的是整个类对象，类似于(X.class)，该类中所有加了synchronized的静态方法，一次只能调用一个。
比较下面两个例子：
public class Synchronized_Test {public static void main(String[] args){Method method=new Method();Thread t1=new Thread(new MyRunnable1(method));Thread t2=new Thread(new MyRunnable2(method));t1.start();t2.start();}}class Method{public synchronized void Method1(){for(int i=0;i<10;i++)System.out.println(Thread.currentThread().getName()+" Method1: "+i);}public synchronized void Method2(){for(int i=0;i<10;i++)System.out.println(Thread.currentThread().getName()+" Method2 "+i);}}class MyRunnable1 implements Runnable{Method method;MyRunnable1(Method method){this.method=method;}public void run() {method.Method1();}}class MyRunnable2 implements Runnable{Method method;MyRunnable2(Method method){this.method=method;}public void run(){method.Method2();}}
输出为：
Thread-0 Method1: 0Thread-0 Method1: 1Thread-0 Method1: 2Thread-0 Method1: 3Thread-0 Method1: 4Thread-0 Method1: 5Thread-0 Method1: 6Thread-0 Method1: 7Thread-0 Method1: 8Thread-0 Method1: 9Thread-1 Method2 0Thread-1 Method2 1Thread-1 Method2 2Thread-1 Method2 3Thread-1 Method2 4Thread-1 Method2 5Thread-1 Method2 6Thread-1 Method2 7Thread-1 Method2 8Thread-1 Method2 9
因为锁住的整个Method对象，在t1执行method1时，给method对象加锁，当t2要执行method2时，因为时synchronized方法，
所以首先要取得method对象的锁，才能执行。
public class Synchronized_Test {public static void main(String[] args){Method method=new Method();Thread t1=new Thread(new MyRunnable1(method));Thread t2=new Thread(new MyRunnable2(method));t1.start();t2.start();}}class Method{public synchronized void Method1(){for(int i=0;i<10;i++)System.out.println(Thread.currentThread().getName()+" Method1: "+i);}public void Method2(){for(int i=0;i<10;i++)System.out.println(Thread.currentThread().getName()+" Method2 "+i);}}class MyRunnable1 implements Runnable{Method method;MyRunnable1(Method method){this.method=method;}public void run() {method.Method1();}}class MyRunnable2 implements Runnable{Method method;MyRunnable2(Method method){this.method=method;}public void run(){method.Method2();}}
输出为：
Thread-0 Method1: 0Thread-1 Method2 0Thread-0 Method1: 1Thread-1 Method2 1Thread-0 Method1: 2Thread-1 Method2 2Thread-0 Method1: 3Thread-1 Method2 3Thread-0 Method1: 4Thread-1 Method2 4Thread-0 Method1: 5Thread-1 Method2 5Thread-0 Method1: 6Thread-1 Method2 6Thread-1 Method2 7Thread-1 Method2 8Thread-1 Method2 9Thread-0 Method1: 7Thread-0 Method1: 8Thread-0 Method1: 9
从结果可以看到，t1并没有阻塞t2的运行，因为t2执行的method2方法不带synchronized，所以在执行时并不需要先获得method对象的锁，执行的过程中也就不存在阻塞的情况。
二、wait、notify和notifyAll
wait、notify、notifyAll是Object对象的属性，并不属于线程。我们先解释这三个的一个很重要的概念
wait：使持有该对象的线程把该对象的控制权交出去，然后处于等待状态（这句话很重要，也就是说当调用wait的时候会释放锁并处于等待的状态）notify：通知某个正在等待这个对象的控制权的线程可以继续运行（这个就是获取锁，使自己的程序开始执行，最后通过notify同样去释放锁，并唤醒正在等待的线程）notifyAll:会通知所有等待这个对象控制权的线程继续运行(和上面一样，只不过是唤醒所有等待的线程继续执行)Obj.wait()与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait与notify是针对已经获取了Obj锁的对象来进行操作
下面来看一个生产者消费者模型，他们有一个缓冲区，缓冲区有最大限制，当缓冲区满的时候，生产者是不能将产品放入到缓冲区里面的，当然，当缓冲区是空的时候，消费者也不能从中拿出来产品，这就涉及到了在多线程中的条件判断，java中提供了wait和notify方法，他们可以在线程不满足要求的时候让线程让出来资源等待，当有资源的时候再notify他们让他们继续工作。
import java.util.Date;import java.util.LinkedList;import java.util.List;class EventStorage {private int maxSize;private List<date> storage;public EventStorage() {maxSize = 10;storage = new LinkedList<date>();}public synchronized void set() {while(storage.size() == maxSize) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}storage.add(new Date());System.out.println("Set: "+storage.size());notifyAll();}public synchronized void get() {while(storage.size() == 0) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("Get: "+storage.size()+" "+((LinkedList<date>)storage).poll());notifyAll();}}class Producer implements Runnable {private EventStorage storge;public Producer(EventStorage storage) {this.storge = storage;}public void run() {for(int i = 0; i < 100; i++) {storge.set();}}}class Consumer implements Runnable {private EventStorage storage;public Consumer(EventStorage storage) {this.storage = storage;}public void run() {for (int i = 0; i < 100; i++) {storage.get();}}}public class ProducerAndConsumer {public static void main(String[] args){EventStorage eventStorage=new EventStorage();Thread t1=new Thread(new Producer(eventStorage));Thread t2=new Thread(new Consumer(eventStorage));t1.start();t2.start();}}
