import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;

class Account{
    
    private int balance;
    private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
    public Account(int balance){
        this.balance=balance;
    }
    
    public int getBalance() {
        return balance;
    }
    
    public void setBalance(int balance) {
        this.balance = balance;
    }
    
      public  void deposit(int money){
         lock.lock();
         try{    
             this.balance=getBalance() + money;
             condition.signal();//类似object的notify
         }
         finally
         {
             lock.unlock();
         }
     }
     public  void withdraw(int money){
         lock.lock();
         try{
             while (getBalance() <money) {
                 try {
                     condition.await();//类似object的wait
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             this.balance=getBalance() - money;
             condition.signal();//类似object的notify
         }
         finally{
             lock.unlock();
         }
     }               
    }

同步方法直接在方法上加synchronized实现加锁，同步代码块则在方法内部加锁，很明显，同步方法锁的范围比较大，而同步代码块范围要小点，一般同步的范围越大，性能就越差，一般需要加锁进行同步的时候，肯定是范围
越小越好，这样性能更好

class Counter {
    private static int id = 0;
    public synchronized static void addId() {
        id++;
    }
    public synchronized static void subtractId() {
        id--;
    }
    public static int getId() {
        return id;
    }
}
同一时间内只能有一个线程访问对象，没有获得对象锁的线程在等待池中等待，等线程释放了对象锁，他们再开始竞争对象锁。

使用wait ()、notify()、notifyAll()实现线程之间的通信。
当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
synchronized可以避免多个线程访问同一资源引起错误。

这个实验关键问题在于让两个线程交替运行，用flag来判断用那个线程来访问资源，输出结果后用notify()唤醒另一个进程。要求我们熟练掌握交替运行。

//201521123045
    public static synchronized void addId() {
            id++;
    }
    public static synchronized void subtractId() {
        id--;
    }
public static synchronized int GetId() {

       return id;
    }

不正常，有时会出现剩余货物还有10个，有可能出现生产者比消费者快，消费者来不及取数据，或者消费者消费的生产者生产的快，消费者取不到数据。

//201521123045
public synchronized void add（String t）{
 if （repo.size()>=capacity）
      try{
          system.out.println("仓库已满，无法添加货物");
          wait();
      }catch(Exception e) {
         system.out.println(e);
       }
       repo.add(t);
       notify();
}
}

线程安全就是就是当一个程序对一个线程安全的方法或者语句进行访问的时候，其他的不能再对他进行操作了，必须等到这次访问结束以后才能对这个线程安全的方法进行访问.
存在竞争的线程不安全，不存在竞争的线程就是安全的。