java中线程同步问题

先不多说，直接上个例子，著名的生产者消费者问题。

 public class ProducerConsumer {
     public static void main(String[] args) {
         SyncStack ss = new SyncStack();
         Producer p = new Producer(ss);
         Consumer c = new Consumer(ss);
         new Thread(p).start();//生产者线程
         new Thread(c).start();//消费者线程
     }
 }
 /**
 消费的物品---窝头
 **/
 class WoTou {
     int id;
     WoTou(int id) {
         this.id = id;
     }
     public String toString() {
         return "WoTou : " + id;
     }
 }
 /**
 消费的空间---堆栈
 **/
 class SyncStack {
     int index = 0;
     WoTou[] arrWT = new WoTou[6];

     public synchronized void push(WoTou wt) {
         while(index == arrWT.length) {//是while而不是if的原因，当wait被打断的时候依旧要检查下堆栈是否满了,否则，由于之前判断过index，从而会跳过判断而导致错误
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         this.notifyAll();
         arrWT[index] = wt;
         index ++;
     }

     public synchronized WoTou pop() {
         while(index == 0) {
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         this.notifyAll();
         index--;
         return arrWT[index];
     }
 }

 /**
 生产者类
 **/
 class Producer implements Runnable {
     SyncStack ss = null;
     Producer(SyncStack ss) {
         this.ss = ss;
     }

     public void run() {
         for(int i=0; i<20; i++) {
             WoTou wt = new WoTou(i);
             ss.push(wt);
 System.out.println("生产了：" + wt);
             try {
                 Thread.sleep((int)(Math.random() * 200));
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }
 /**
 消费者类
 **/
 class Consumer implements Runnable {
     SyncStack ss = null;
     Consumer(SyncStack ss) {
         this.ss = ss;
     }

     public void run() {
         for(int i=0; i<20; i++) {
             WoTou wt = ss.pop();
 System.out.println("消费了: " + wt);
             try {
                 Thread.sleep((int)(Math.random() * 1000));
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }

效果如图：

synchronized的引入，学过数据库系统和操作系统的朋友应该会有所了解，对于共享资源，当一个线程占用的时候不能被其他线程操作，和操作系统的原子操作的原理有些相似。

对于synchronized的理解：

synchronized(对象){

同步代码块

}

当是非static synchronized函数时，默认对象为this；当为是static synchronized函数时，默认为当前对象.class。

而wait,notify,notifyAll时，前面必须指定锁，即对象(原因：因为如果出现synchronized嵌套的时候会出错，这个好比一个游戏，一个锁是一组，只有在一组之内wait，notify，notifyAll有效，而对于另外一个组是无效的。)

wait的引入：例如上题堆栈中只能放6个窝头，但是当堆栈中有6个窝头的时候，生产者获得对象锁的时候就不能生产了，因此，生产者就会进入wait池，同时又会释放对象锁。

notify的引入：唤醒wait池中的一个线程（ps：只能唤醒别的线程，不能唤醒自己）

notifyall的引入：唤醒wait池中的所有线程

在最后，给大家说下wait和sleep的区别吧，个人理解：

1.wait是Object类中方法，会抛出InteruptException，sleep是Thread类中的方法，wait方法只用在获得对象锁得时候才能用，否则会抛异常；

2.wait方法会释放对象锁，但是sleep不会释放对象锁；

3.wait后的线程需要其他的线程去唤醒，但是sleep的线程在规定的时间后会自动唤醒。