黑马程序员技术交流社区

标题: 静态变量同步的问题 [打印本页]
作者: 吴璞玉    时间: 2012-3-13 18:02
标题: 静态变量同步的问题
在类中给2个以上的静态方法加synchronized时，那么线程会不会同时进入这2个静态方法？线程如果同时执行类中的非静态方法，如果这个时候类中的非静态方法修改了静态变量的值，那静态变量的同步岂不是失败了么
作者: 张锐    时间: 2012-3-13 21:21
写了个例子验证了一下：
  1. package test;

  3. import myutil.SOP;

  5. public class TestSynchronized2 {

  7.         /**
  8.          * @param args
  9.          * @throws InterruptedException
  10.          */
  11.         public static void main(String[] args) throws InterruptedException {
  12.                 // TODO Auto-generated method stub
  13.                 MySync2 ms1 = new MySync2();
  14.                 ms1.setFlag(1);
  15.                 MySync2 ms2 = new MySync2();
  16.                 ms2.setFlag(2);
  17.                 MySync2 ms3 = new MySync2();
  18.                 ms3.setFlag(3);
  19.                
  20.                 Thread t1 = new Thread(ms1);
  21.                 Thread t2 = new Thread(ms2);
  22.                 Thread t3 = new Thread(ms3);
  23.                 t1.start();
  24.                 Thread.sleep(100);
  25.                 t2.start();
  26.                 t3.start();
  27.         }

  29. }

  31. class MySync2 implements Runnable{
  32.         private int flag = 0;
  33.         private static int i = 0;
  34.        
  35.         public void setFlag(int flag) {
  36.                 this.flag = flag;
  37.         }
  38.        
  39.         static synchronized void method1() throws InterruptedException{
  40.                 i=10;
  41.                 Thread.sleep(5000);
  42.                 SOP.sop("method1---"+i);
  43.         }
  44.         static synchronized void method2() throws InterruptedException{
  45.                 i=20;
  46.                 Thread.sleep(2000);
  47.                 SOP.sop("method2---"+i);
  48.         }
  49.         void method3() throws InterruptedException{
  50.                 i = 1000;
  51.                 SOP.sop("method3---"+i);
  52.         }
  53.         @Override
  54.         public void run() {
  55.                 switch (flag) {
  56.                 case 1:
  57.                         try {
  58.                                 method1();
  59.                         } catch (InterruptedException e) {
  60.                                 // TODO Auto-generated catch block
  61.                                 e.printStackTrace();
  62.                         }
  63.                         break;
  64.                 case 2:
  65.                         try {
  66.                                 method2();
  67.                         } catch (InterruptedException e) {
  68.                                 // TODO Auto-generated catch block
  69.                                 e.printStackTrace();
  70.                         }
  71.                         break;
  72.                 case 3:
  73.                         try {
  74.                                 method3();
  75.                         } catch (InterruptedException e) {
  76.                                 // TODO Auto-generated catch block
  77.                                 e.printStackTrace();
  78.                         }
  79.                         break;

  81.                 default:
  82.                         SOP.sop("here is default");
  83.                         break;
  84.                 }
  85.                 // TODO Auto-generated method stub
  86.                
  87.         }
  88. }
复制代码
结果是：
method3---1000
method1---1000
method2---20

得出的结论是：
静态方法的默认的锁是类本身，所以两个静态的方法是不可能同时被调用的，只有一前一后的顺序。但是非静态方法就不一定了。
上面这个例子的情况是：
t1先把 i 改成10，然后锁上，这时候t2不可以进来了，但是因为t3不受锁的限制，进来把 i 改成1000 并且输出，后来t1醒来后，i 已经变成1000了，所以输出1000，t1释放所后，t2再进来，把 i 改成20，然后输出20.
   



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2