java 线程同步总结

一、当多个线程同时操作同一个资源，就会出现线程的不同步，信息的不对称

经典的银行存取例子：

public class Bank implements Runnable {
   int money=200;
   public void setMoney(int n) {
      money=n;
   }
   public void run() {
      if(Thread.currentThread().getName().equals("会计")) 
         saveOrTake(300);
      else if(Thread.currentThread().getName().equals("出纳"))
         saveOrTake(150);
   }
    public synchronized void saveOrTake(int amount) { //存取方法
      if(Thread.currentThread().getName().equals("会计")) {
         for(int i=1;i<=3;i++) { 
             money=money+amount/3;      //每存入amount/3，稍歇一下
             System.out.println(Thread.currentThread().getName()+
                               "存入"+amount/3+",帐上有"+money+"万,休息一会再存");
             try { Thread.sleep(1000);  //这时出纳仍不能使用saveOrTake方法 
             }                       
             catch(InterruptedException e){}
         }
      }
      else if(Thread.currentThread().getName().equals("出纳")) {
         for(int i=1;i<=3;i++) { //出纳使用存取方法取出60
             money=money-amount/3;   //每取出amount/3，稍歇一下
             System.out.println(Thread.currentThread().getName()+
                               "取出"+amount/3+"帐上有"+money+"万,休息一会再取");
             try { Thread.sleep(1000);       //这时会计仍不能使用saveOrTake方法
             }                         
             catch(InterruptedException e){}
         }
      }
   }
}

测试:

public static void main(String args[]) {
      Bank bank = new Bank();
      bank.setMoney(200);
      Thread accountant,    //会计
             cashier;      //出纳
      accountant = new Thread(bank);
      cashier = new Thread(bank);
      accountant.setName("会计");
      cashier.setName("出纳");
      accountant.start();
      cashier.start(); 
   }

在这个例子中，saveOrtake()方法，用了synchronized关键字，如果我们去掉这个关键字，多个线程会同时进入saveOrtake方法，同时修改同一个关键数据，就有可能造成数据的不同步，（这个关键数据永远是同步的，不过是修改的顺序不同，但是其它对这个数据的引用就可能会不同步比如打印，函数参数引用，有可能在一个处理还没有完成的时候，被另一个线程改变了数据），所以在java中用synchronized关键字，实现同步方法，一次只能有一个线程执行该方法，其他线程必须等待。

二、synchronized 详解

总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。

在进一步阐述之前，我们需要明确几点：

    A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。这个对象锁就是当前调用这个方法的对象。

    B．每个对象只有一个锁（lock）与之相关联。

   C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

    D. 推荐使用synchronized（this）代码块的方式，可以自定义对象锁，自定义同步区域，灵活性较高。

E . synchronized的对象锁，是目标对象的实例，如果重新new了一个对象，那么新的线程仍然可以访问同步方法，因为对象锁不是同一个。

1.对象锁

    Public synchronized void methodAAA()

    {

         //….

     }

上边的示例代码等同于如下代码：

    public void methodAAA()

    {

      synchronized (this)      //  (1)

    {

          //…..

    }

    }

    可见同步方法实质是将 synchronized 作用于 object reference，谁拿到了当前的对象锁，谁就可以调用。

2. 当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：

     class Foo implements Runnable

    {

          private byte[] lock = new byte[0];  // 特殊的instance变量

         Public void methodA()

     {

          synchronized(lock) { //… }

     }

       //…..

     }

注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

三、协调进程同步 wait，notify

1.不要以为加上synchronized就安全了，仍然可能出现线程的死锁，而且正是由于线程同步造成的，请看例子

public class TicketHouse implements Runnable {
   int fiveAmount=2,tenAmount=0,twentyAmount=0; 
   public void run() {
      if(Thread.currentThread().getName().equals("张飞")) {
          saleTicket(20);
      }
      else if(Thread.currentThread().getName().equals("李逵")) {
          saleTicket(5);
      }
   }
   private synchronized void saleTicket(int money) {
       if(money==5) {  //如果使用该方法的线程传递的参数是5,就不用等待
        fiveAmount=fiveAmount+1; 
        System.out.println( "给"+Thread.currentThread().getName()+"入场卷,"+
                            Thread.currentThread().getName()+"的钱正好");
       }
       else if(money==20) {           
         while(fiveAmount<3) {
            try { System.out.println("\n"+Thread.currentThread().getName()+"靠边等...");
                  wait();       //如果使用该方法的线程传递的参数是20须等待
                  System.out.println("\n"+Thread.currentThread().getName()+"继续买票");
            }
            catch(InterruptedException e){}
         }
         fiveAmount=fiveAmount-3;
         twentyAmount=twentyAmount+1;
         System.out.println("给"+Thread.currentThread().getName()+"入场卷,"+
                            Thread.currentThread().getName()+"给20，找赎15元");
       }
       notifyAll();//唤醒一个线程
   } 
}

测试

 public static void main(String args[ ]) {
      TicketHouse officer = new TicketHouse();
      Thread zhangfei,likui;
      zhangfei = new Thread(officer); 
      zhangfei.setName("张飞");
      likui = new Thread(officer);  
      likui.setName("李逵");
      zhangfei.start();
      likui.start();
   }

首先我们先不看 wait 和notify 方法，由于saleTicket是同步的，当张飞进入saleTicket后，李奎线程进入等待，总共只有2个5块，但是张飞给的是20，不够找，程序会一直在while（fiveAmount<3）处，循环，而李奎线程将一直等待，

进入死锁。所以我们需要手动的协调线程同步的方法，也就是wait 和 notify方法。

2. Wait()和notify():如果条件不满足，则等待。当条件满足时，等待该条件的线程将被唤醒。用在synchronized机制中。

例如:线程A

   synchronized(obj) {

               while(!condition) {

                         obj.wait();

                 }

                obj.doSomething();

  }

当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A就wait()。在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就可以唤醒线程A。

线程B

      synchronized(obj) {

              condition = true;

              obj.notify();

        }

四、需要注意的概念是：  

   1.调用obj的wait()， notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {……} 代码段内。  

   2.调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {……} 代码段内唤醒A.  

   3.当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。  

   4.如果A1，A2，A3都在obj.wait()，则B调用obj.notify()只能唤醒A1，A2，A3中的一个（具体哪一个由JVM决定）。  

   5.obj.notifyAll()则能全部唤醒A1，A2，A3，但是要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1，A2，A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。

   6.当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1，A2，A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1，A2，A3中的一个才有机会获得锁继续执行。