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的线程在规定的时间后会自动唤醒。