Java 多线程, 同步访问, 线程锁，锁对象,ReentrantLock,synchronized

1.为什么要同步访问数据？

　　当两个或以上的线程需要共享对同一数据的存取，可能会发生共享数据的讹误。

2.实现同步的方式

　　2.1 ReentrantLock类

　　　　School类：

        class School{
        
            private int stuNum;
            private Lock lock;
　　　　　　　private Condition condition;
        
            public School(int stuNum) {
                this.stuNum = stuNum;
                lock = new ReentrantLock();
                condition = lock.newCondition();
            }
        ......

　　　　其中 lock是锁对象， condition 是条件对象，

　　　　用法：

        public void stuNums1(){
            lock.lock();
            try{
                while (stuNum < 20){
                    System.out.println(stuNum+" < 20,等待数量变为20");
                    condition.await();
                }
                stuNum -= 5;
                System.out.println(Thread.currentThread().toString() + ":" + stuNum);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }
        public void stuNums2(){
            lock.lock();
            try{
                stuNum += 1;
                System.out.println(Thread.currentThread().toString() + ":" + stuNum);
                if (stuNum >= 20){
                    System.out.println(stuNum + ">20了，开始唤醒等待集的线程");
                    condition.signalAll();
                }
            } finally {
                lock.unlock();
            }

        }

　　　　当条件对象调用await()方法时候，当前线程会进入等待集，处于阻塞状态，直到其他线程在同一条件上调用signalAll()方法为止。

　　　　当一个线程调用await()方法时候，没有办法重新激活自身，寄希望于其他线程，如果没有其他线程重新激活等待中的线程，将会导致死锁。

　　　　在对象状态有利于等待线程的方向改变时调用signalAll()方法，解除等待线程的阻塞。

　　2.2 synchronized关键字

　　　　在声明方法时，加上这个关键字，对象锁会保护整个方法。其效果等价于2.1中的方法。

　　　　在这里  wait() notufyAll() 分别等价于 await() signalAll()方法。