（我以前有几个问题可能没有说清楚，以后我会尽量说清楚一些的，{:soso_e100:} ）

刚看到了多线程同步的章节，就按毕老师写的，自己稍微改了一下实现的是两个储户分帐户存放自己的Money,我把代码全部放同步函数jihe()里，和直接全部放同步代码快中，跑出来的数据竟然是不一样的，也就是说同步代码快和同步函数实现了不一样的处理，为什么会出现这样的情况呢？

以下是我的代码：

1. 
   
2. class Bank
   
3. {
   
4.         private int sum;
   
5.         public  void add(int n)
   
6.         {
   
7.                        
   
8.                         sum=sum+n;
   
9.                         System.out.println(Thread.currentThread().getName()+"   sum="+sum);
   
10.                
    
11.         }
    
12. }
    
13. 
    
14. class Cus implements Runnable
    
15. {
    
16.        
    
17.         public void run()
    
18.         {       
    
19.                 synchronized(new Object())
    
20.                 {
    
21.                         Bank b=new Bank();
    
22.                         for(int x=0;x<10;x++)
    
23.                         {
    
24.                                 b.add(100);
    
25.                         }
    
26. 
    
27.                         //jihe();                                             //把上面的代码全部放在了jihe同步函数中
    
28.                 }
    
29.         }
    
30. 
    
31.         /*
    
32.         public synchronized void jihe()
    
33.         {
    
34.                         Bank b=new Bank();
    
35.                         for(int x=0;x<10;x++)
    
36.                         {
    
37.                                 b.add(100);
    
38.                         }
    
39.        
    
40.         }*/
    
41. }
    
42. 
    
43. 
    
44. class Test
    
45. {
    
46.         public static void main(String args[])
    
47.         {
    
48.                 Cus c=new Cus();
    
49.                 Thread t1=new Thread(c,"储户1");
    
50.                 Thread t2=new Thread(c,"储户2");
    
51.                 t1.start();
    
52.                 t2.start();
    
53.         }
    
54. }

复制代码

我找到原因了，原来是synchronized(new Object())这里的问题，

class Cus implements Runnable
{
        Object a=new Object();                 //需要这样处理后才能实现，原来是针对同一个对象才能实现！
        public void run()
        {       
                synchronized(a)
                {
                        Bank b=new Bank();
                        for(int x=0;x<10;x++)
                        {
                                b.add(100);
                        }

                        //jihe();
                }
        }


很奇怪，每次问完问题后，就很快能找到问题的原因，不问的话，一下又想不到，到低是问呢？还是不问呢？？有些困惑。