1. package j2se.thread.test;
  2.  
  3. /***
  4.  * synchronized(class)很特别，它会让另一个线程在任何需要获取class做为monitor的地方等待．
  5.  * class与this做为不同的监视器可以同时使用，不存在一个线程获取了class，另一个线程就不能获取该class的一切实例．
  6.         根据下面的代码自行修改,分别验证下面的几种情况：
  7.     synchronized(class)
  8.     synchronized(this)
  9.     －＞线程各自获取monitor，不会有等待．
  10.     synchronized(this)
  11.     synchronized(this)
  12.     －＞如果不同线程监视同一个实例对象，就会等待，如果不同的实例，不会等待．
  13.     synchronized(class)
  14.     synchronized(class)
  15.     －＞如果不同线程监视同一个实例或者不同的实例对象，都会等待．
  16.  */
  17.  
  18. /**
  19.  * @author liwei
  20.     测试synchronized(this)与synchronized(class)
  21.  */
  22. public class TestSynchronied8 {
  23.      private  static byte[] lockStatic = new byte[0]; // 特殊的instance变量
  24.      private byte[] lock = new byte[0]; // 特殊的instance变量
  25.  
  26.      public synchronized void m4t5() {
  27.          System.out.println(this);
  28.           int i = 50;
  29.           while( i-- > 0) {
  30.                System.out.println(Thread.currentThread().getName() + " : " + i);
  31.                try {
  32.                     Thread.sleep(100);
  33.                } catch (InterruptedException ie) {
  34.                }
  35.                Thread.yield();
  36.           }
  37.     } 
  38.  
  39.      public void m4t0() {
  40.          synchronized(this) {
  41.              System.out.println(this);
  42.               int i = 50;
  43.               while( i-- > 0) {
  44.                    System.out.println(Thread.currentThread().getName() + " : " + i);
  45.                    try {
  46.                         Thread.sleep(100);
  47.                    } catch (InterruptedException ie) {
  48.                    }
  49.                    Thread.yield();
  50.               }
  51.          }
  52.     } 
  53.  
  54.      public void m4t1() {
  55.          synchronized(lock) {
  56.              System.out.println(this);
  57.               int i = 50;
  58.               while( i-- > 0) {
  59.                    System.out.println(Thread.currentThread().getName() + " : " + i);
  60.                    try {
  61.                         Thread.sleep(100);
  62.                    } catch (InterruptedException ie) {
  63.                    }
  64.                    Thread.yield();
  65.               }
  66.          }
  67.     }
  68.      /**
  69.      * synchronized(class)
  70.         synchronized(class)
  71.         －＞如果不同线程监视同一个实例或者不同的实例对象，都会等待．
  72.      */
  73.     public static synchronized void m4t2() {
  74.           int i = 50;
  75.           while( i-- > 0) {
  76.                System.out.println(Thread.currentThread().getName() + " : " + i);
  77.                try {
  78.                     Thread.sleep(100);
  79.                } catch (InterruptedException ie) {
  80.                }
  81.                Thread.yield();
  82.  
  83.           }
  84.     } 
  85.  
  86.     public static  void m4t3() {
  87.         synchronized(TestSynchronied8.class){
  88.             int i = 50;
  89.             while( i-- > 0) {
  90.                  System.out.println(Thread.currentThread().getName() + " : " + i);
  91.                  try {
  92.                       Thread.sleep(100);
  93.                  } catch (InterruptedException ie) {
  94.                  }
  95.                  Thread.yield();
  96.             }
  97.         }
  98.   } 
  99.  
  100.     public static  void m4t4() {
  101.         synchronized(lockStatic){
  102.             int i = 50;
  103.             while( i-- > 0) {
  104.                  System.out.println(Thread.currentThread().getName() + " : " + i);
  105.                  try {
  106.                       Thread.sleep(100);
  107.                  } catch (InterruptedException ie) {
  108.                  }
  109.                  Thread.yield();
  110.             }
  111.         }
  112.   } 
  113.  
  114.  /**
  115.     synchronized(this)
  116.     synchronized(this)
  117.     －＞如果不同线程监视不同的实例，不会等待．
  118.  */
  119. public static void testObjsyn1(){
  120.     final TestSynchronied8 myt2 = new TestSynchronied8();
  121.     final TestSynchronied8 myt1 = new TestSynchronied8();
  122.     try {
  123.         System.out.println("测试两个不同的对象上，运行同一个synchronized（this）代码块-------------------------------------");
  124.         Thread.sleep(500);
  125.     } catch (InterruptedException e) {
  126.         e.printStackTrace();
  127.     }
  128.     Thread t1 = new Thread(  new Runnable() {  public void run() {  myt1.m4t0();  }  }, "t1"  );
  129.     Thread t2 = new Thread(  new Runnable() {  public void run() {  myt2.m4t0();  }  }, "t2"  );
  130.     t1.start();
  131.     t2.start();
  132. } 
  133.  
  134. /**
  135. synchronized(this)
  136. synchronized(this)
  137. －＞如果不同线程监视同一个实例，会等待．
  138. */
  139. public static void testObjsyn2(){
  140.     final TestSynchronied8 myt1 = new TestSynchronied8();
  141.     try {
  142.         System.out.println("测试一个对象上，运行同一个synchronized（this）代码块-------------------------------------");
  143.         Thread.sleep(500);
  144.     } catch (InterruptedException e) {
  145.         e.printStackTrace();
  146.     }
  147.     Thread t3 = new Thread(  new Runnable() {  public void run() {  myt1.m4t0();  }  }, "t3"  );
  148.     Thread t4 = new Thread(  new Runnable() {  public void run() {  myt1.m4t0();  }  }, "t4"  );
  149.     t3.start();
  150.     t4.start();
  151. } 
  152.  
  153. /**
  154. synchronized(this)
  155. synchronized(this)
  156. －＞如果不同线程监视同一个实例，会等待．
  157. */
  158. public static void testObjsyn3(){
  159.     final TestSynchronied8 myt1 = new TestSynchronied8();
  160.     try {
  161.         System.out.println("测试一个对象上，运行同一个synchronized(obj)代码块-------------------------------------");
  162.         Thread.sleep(500);
  163.     } catch (InterruptedException e) {
  164.         e.printStackTrace();
  165.     }
  166.     Thread t5 = new Thread(  new Runnable() {  public void run() {  myt1.m4t1();  }  }, "t5"  );
  167.     Thread t6 = new Thread(  new Runnable() {  public void run() {  myt1.m4t1();  }  }, "t6"  );
  168.     t5.start();
  169.     t6.start();
  170. } 
  171.  
  172. /**
  173. synchronized(this)
  174. synchronized(this)
  175. －＞如果不同线程监视同一个实例，会等待．
  176. */
  177. public static void testObjsyn4(){
  178.     final TestSynchronied8 myt1 = new TestSynchronied8();
  179.     try {
  180.         System.out.println("测试一个对象上，运行同一个synchronized方法-------------------------------------");
  181.         Thread.sleep(500);
  182.     } catch (InterruptedException e) {
  183.         e.printStackTrace();
  184.     }
  185.     Thread t7 = new Thread(  new Runnable() {  public void run() {  myt1.m4t5();  }  }, "t7"  );
  186.     Thread t8 = new Thread(  new Runnable() {  public void run() {  myt1.m4t5();  }  }, "t8"  );
  187.     t7.start();
  188.     t8.start();
  189. } 
  190.  
  191. /**
  192. synchronized(this)
  193. synchronized(this)
  194. －＞如果不同线程监视不同的实例，不会等待．
  195. */
  196. public static void testObjsyn5(){
  197.     final TestSynchronied8 myt1 = new TestSynchronied8();
  198.     final TestSynchronied8 myt2 = new TestSynchronied8();
  199.     try {
  200.         System.out.println("测试两个不同对象上，运行同一个synchronized方法-------------------------------------");
  201.         Thread.sleep(500);
  202.      } catch (InterruptedException e) {
  203.         e.printStackTrace();
  204.      }
  205.      Thread t9 = new Thread(  new Runnable() {  public void run() {  myt1.m4t5();  }  }, "t9"  );
  206.      Thread t10 = new Thread(  new Runnable() {  public void run() {  myt2.m4t5();  }  }, "t10"  );
  207.      t9.start();
  208.      t10.start();
  209. } 
  210.  
  211. /**
  212. synchronized(this)
  213. synchronized方法
  214. －＞如果不同线程监视同一实例，一个是syschronized（this），一个是同步方法，会等待．
  215. */
  216. public static void testObjsyn6(){
  217.     final TestSynchronied8 myt1 = new TestSynchronied8();
  218.     try {
  219.         Thread.sleep(500);
  220.      } catch (InterruptedException e) {
  221.         e.printStackTrace();
  222.      }
  223.      Thread t9 = new Thread(  new Runnable() {  public void run() {  myt1.m4t0();  }  }, "t9"  );
  224.      Thread t10 = new Thread(  new Runnable() {  public void run() {  myt1.m4t5();  }  }, "t10"  );
  225.      t9.start();
  226.      t10.start();
  227. }
  228.  
  229. /**
  230. synchronized(lock)
  231. synchronized方法
  232. －＞如果不同线程监视同一实例，一个是syschronized（lock），一个是同步方法，不会等待．
  233. */
  234. public static void testObjsyn7(){
  235.     final TestSynchronied8 myt1 = new TestSynchronied8();
  236.     try {
  237.         Thread.sleep(500);
  238.      } catch (InterruptedException e) {
  239.         e.printStackTrace();
  240.      }
  241.      Thread t9 = new Thread(  new Runnable() {  public void run() {  myt1.m4t1();  }  }, "t9"  );
  242.      Thread t10 = new Thread(  new Runnable() {  public void run() {  myt1.m4t5();  }  }, "t10"  );
  243.      t9.start();
  244.      t10.start();
  245. }
  246.  
  247. /**
  248. synchronized(lock)
  249. synchronized方法
  250. －＞如果不同线程监视同一实例，一个是syschronized（lock），一个是syschronized（this），不会等待．
  251. */
  252. public static void testObjsyn71(){
  253.     final TestSynchronied8 myt1 = new TestSynchronied8();
  254.     try {
  255.         Thread.sleep(500);
  256.      } catch (InterruptedException e) {
  257.         e.printStackTrace();
  258.      }
  259.      Thread t9 = new Thread(  new Runnable() {  public void run() {  myt1.m4t0();  }  }, "t9"  );
  260.      Thread t10 = new Thread(  new Runnable() {  public void run() {  myt1.m4t1();  }  }, "t10"  );
  261.      t9.start();
  262.      t10.start();
  263. }
  264.  
  265. /**
  266.      * synchronized(class)
  267.         synchronized(class)
  268.         －＞如果不同线程监视不同的实例对象，会等待．
  269.  */
  270. public static void testObjsyn8(){
  271.     final TestSynchronied8 myt1 = new TestSynchronied8();
  272.     final TestSynchronied8 myt2 = new TestSynchronied8();
  273.     try {
  274.         Thread.sleep(500);
  275.      } catch (InterruptedException e) {
  276.         e.printStackTrace();
  277.      }
  278.    Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  );
  279.    Thread t4 = new Thread(  new Runnable() {  public void run() { myt1.m4t2();   }  }, "t4"  );
  280.    t2.start();
  281.    t4.start();
  282. }
  283.  
  284. /**
  285.  * synchronized(class)
  286.     synchronized(class)
  287.     －＞如果不同线程监视同一的实例对象，会等待．
  288. */
  289. public static void testObjsyn9(){
  290.     final TestSynchronied8 myt1 = new TestSynchronied8();
  291.     try {
  292.         Thread.sleep(500);
  293.      } catch (InterruptedException e) {
  294.         e.printStackTrace();
  295.      }
  296.     Thread t2 = new Thread(  new Runnable() {  public void run() { myt1.m4t2();   }  }, "t2"  );
  297.     Thread t4 = new Thread(  new Runnable() {  public void run() { myt1.m4t2();   }  }, "t4"  );
  298.     t2.start();
  299.     t4.start();
  300. }
  301.  
  302. /**
  303.  * synchronized(class)
  304.     synchronized(this)
  305.     －＞线程各自获取monitor，不会有等待．
  306.  */
  307. public static void testObjsyn10(){
  308.     final TestSynchronied8 myt1 = new TestSynchronied8();
  309.     final TestSynchronied8 myt2 = new TestSynchronied8();
  310.     try {
  311.         Thread.sleep(500);
  312.      } catch (InterruptedException e) {
  313.         e.printStackTrace();
  314.      }
  315.     Thread t7 = new Thread(  new Runnable() {  public void run() { myt2.m4t0();   }  }, "t7"  );
  316.     Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t3();   }  }, "t8"  );
  317.     t7.start();
  318.     t8.start();
  319. }
  320.  
  321. /**
  322.  * synchronized(class)
  323.     synchronized(this)
  324.     －＞线程各自获取monitor，不会有等待．
  325.  */
  326. public static void testObjsyn11(){
  327.     final TestSynchronied8 myt1 = new TestSynchronied8();
  328.     try {
  329.         Thread.sleep(500);
  330.      } catch (InterruptedException e) {
  331.         e.printStackTrace();
  332.      }
  333.     Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t0();   }  }, "t7"  );
  334.     Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t3();   }  }, "t8"  );
  335.     t7.start();
  336.     t8.start();
  337. }
  338.  
  339. /**
  340.  * synchronized(class)
  341.     synchronized(lock)
  342.     －＞线程各自获取monitor，不会有等待．
  343.  */
  344. public static void testObjsyn12(){
  345.     final TestSynchronied8 myt1 = new TestSynchronied8();
  346.     try {
  347.         Thread.sleep(500);
  348.      } catch (InterruptedException e) {
  349.         e.printStackTrace();
  350.      }
  351.     Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t1();   }  }, "t7"  );
  352.     Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t3();   }  }, "t8"  );
  353.     t7.start();
  354.     t8.start();
  355. }
  356.  
  357. /**
  358.  * synchronized(class)
  359.     synchronized(lockStatic)
  360.     －＞线程各自获取monitor，不会有等待．
  361.  */
  362. public static void testObjsyn13(){
  363.     final TestSynchronied8 myt1 = new TestSynchronied8();
  364.     try {
  365.         Thread.sleep(500);
  366.      } catch (InterruptedException e) {
  367.         e.printStackTrace();
  368.      }
  369.     Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t4();   }  }, "t7"  );
  370.     Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t3();   }  }, "t8"  );
  371.     t7.start();
  372.     t8.start();
  373. }
  374.  
  375. /**
  376.  * synchronized方法
  377.     synchronized(lockStatic)
  378.     －＞线程各自获取monitor，不会有等待．
  379.  */
  380. public static void testObjsyn14(){
  381.     final TestSynchronied8 myt1 = new TestSynchronied8();
  382.     try {
  383.         Thread.sleep(500);
  384.      } catch (InterruptedException e) {
  385.         e.printStackTrace();
  386.      }
  387.     Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t4();   }  }, "t7"  );
  388.     Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t2();   }  }, "t8"  );
  389.     t7.start();
  390.     t8.start();
  391. }
  392.  
  393. /**
  394.  * synchronized方法
  395.     synchronized(lockStatic)
  396.     －＞线程各自获取monitor，不会有等待．
  397.  */
  398. public static void testObjsyn15(){
  399.     final TestSynchronied8 myt1 = new TestSynchronied8();
  400.     try {
  401.         Thread.sleep(500);
  402.      } catch (InterruptedException e) {
  403.         e.printStackTrace();
  404.      }
  405.     Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t3();   }  }, "t7"  );
  406.     Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t2();   }  }, "t8"  );
  407.     t7.start();
  408.     t8.start();
  409. }
  410.  
  411. /**
  412.  * synchronized方法
  413.     synchronized(lockStatic)
  414.     －＞线程各自获取monitor，不会有等待．
  415.  */
  416. public static void testObjsyn16(){
  417.     final TestSynchronied8 myt1 = new TestSynchronied8();
  418.     try {
  419.         Thread.sleep(500);
  420.      } catch (InterruptedException e) {
  421.         e.printStackTrace();
  422.      }
  423.     Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t1();   }  }, "t7"  );
  424.     Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t4();   }  }, "t8"  );
  425.     t7.start();
  426.     t8.start();
  427. }
  428.  
  429.     /**
  430.      *  synchronized(class)和static synchronized 方法所获取的锁是一样的
  431.      *  synchronized(class)方法和静态的方法中的 synchronized(lockStatic)代码块获取的锁是不一样的
  432.      *  非静态的方法中的synchronized(this)代码块和非静态的 synchronized 方法所获取的锁是一样的
  433.      * (静态和非静态) synchronized(this)和(静态和非静态)的 synchronized(lock)代码块获取的锁是不一样的
  434.      *
  435.      * 总的来说synchronized(class)和static synchronized 方法获取的是类锁
  436.      * 非静态的方法中的synchronized(this)代码块和非静态的 synchronized 方法所获取的锁是类的实例的对象锁
  437.      *  synchronized(lockStatic)获取的是静态属性的锁
  438.      *  synchronized(lock) 获取的是非静态属性的锁
  439.      *  如果获取的锁是一样的，代码就会同步 ；锁不一样就不会同步
  440.      */
  441.     public static void main(String[] args) {
  442.         //对于非静态的方法，同步方法和 synchronized(this) 获取的是实例对象锁
  443.         //对于非静态的方法，同步方法和 synchronized(lock) 获取的锁的lock
  444.  
  445. //        testObjsyn1();//如果不同线程监视不同的实例，不会等待． synchronized(this)
  446. //        testObjsyn2();//如果不同线程监视同一个实例，会等待． synchronized(this)
  447. //        testObjsyn3();//如果不同线程监视同一个实例，会等待． synchronized(lock)
  448. //        testObjsyn4();//如果不同线程监视同一个实例，会等待． synchronized 方法
  449. //        testObjsyn5();//如果不同线程监视不同的实例，不会等待． synchronized 方法
  450. //        testObjsyn6();//如果不同线程监视同一实例，一个是syschronized（this），一个是同步方法，会等待
  451. //        testObjsyn7(); //如果不同线程监视同一实例，一个是syschronized（lock），一个是同步方法，不会等待，锁定的对象不一样的
  452. //        testObjsyn71(); //如果不同线程监视同一实例，一个是syschronized（lock），一个是syschronized（this），不会等待，锁定的对象不一样的
  453.  
  454.         /**
  455.            * synchronized(class)
  456.               synchronized(class)
  457.               －＞如果不同线程监视同一个实例或者不同的实例对象，都会等待．
  458.            */
  459. //        testObjsyn8();//如果不同线程监视不同的实例对象，会等待．synchronized(class)
  460. //        testObjsyn9();//如果不同线程监视同一的实例对象，会等待．synchronized(class)
  461. //        testObjsyn10();//如果不同线程监视不同的实例对象，不会等待．synchronized(class)，synchronized(this)
  462. //        testObjsyn11();//如果不同线程监视同一的实例对象，不会等待．synchronized(class)，synchronized(this)
  463. //        testObjsyn12();//如果不同线程监视同一的实例对象，不会等待．synchronized(class)，synchronized(lock)
  464. //        testObjsyn13();//如果不同线程监视同一的实例对象，不会等待．synchronized(class)，synchronized(lockStatic)
  465. //        testObjsyn14();//如果不同线程监视同一的实例对象，不会等待．synchronized()方法，synchronized(lockStatic)
  466. //        testObjsyn15();//如果不同线程监视同一的实例对象，会等待．synchronized()方法，synchronized(class)
  467. //        testObjsyn16();//如果不同线程监视同一的实例对象，不会等待．synchronized(lock)方法，synchronized(lockStatic)        
  468.  
  469.     }
  470. }

java 中关于synchronized的通常用法的更多相关文章

  1. 巨人大哥谈Java中的Synchronized关键字用法

    巨人大哥谈Java中的Synchronized关键字用法 认识synchronized 对于写多线程程序的人来说,经常碰到的就是并发问题,对于容易出现并发问题的地方价格synchronized基本上就 ...

  2. JAVA中字符串函数subString的用法小结

    本篇文章主要是对JAVA中字符串函数subString的用法进行了详细的介绍,需要的朋友可以过来参考下,希望对大家有所帮助 String str; str＝str.substring(int begi ...

  3. 【Java学习笔记之二十九】Java中的"equals"和"=="的用法及区别

    Java中的"equals"和"=="的用法及区别 在初学Java时,可能会经常碰到下面的代码: String str1 = new String(" ...

  4. java中 this 的三种用法

    Java中this的三种用法 调用属性 (1)this可以调用本类中的任何成员变量 调用方法(可省略) (2)this调用本类中的成员方法(在main方法里面没有办法通过this调用) 调用构造方法 ...

  5. Java中枚举的写法和用法

            在公司代码中,用了一大堆的枚举,看得我好懵逼.下面开始看看枚举怎么写和怎么用. 一.枚举的写法         关于枚举的写法,网上好多这方面的知识.这里直接贴一个我自己写的枚举类的代 ...

  6. Java中try,catch,finally的用法

    Java中try,catch,finally的用法,以前感觉还算熟悉,但看到一篇博文才有更深点的理解,总结网友博客如下. Java异常处理的组合方式: 1.try+catch  运行流程:运行到try ...

  7. 对kotlin和java中的synchronized的浅谈

    synchronized在java中是一个关键字,但是在kotlin中是一个内联函数.假如分别在java和kotlin代码锁住同一个对象,会发生什么呢,今天写了代码试了试.首先定义people类 12 ...

  8. Java中的Synchronized关键字用法

    认识synchronized 对于写多线程程序的人来说,经常碰到的就是并发问题,对于容易出现并发问题的地方加上synchronized修饰符基本上就搞定 了,如果说不考虑性能问题的话,这一招绝对能应对 ...

  9. 深入理解java中的synchronized关键字

    synchronized 关键字,代表这个方法加锁,相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B(或者C D等),有的话要等正在使用这个方法的线程B(或者C D ...

随机推荐

  1. Mifare系列5-存储结构（转）

    文/闫鑫原创转载请注明出处http://blog.csdn.net/yxstars/article/details/38081521 Mifare S50把1K字节的容量分为16个扇区(Sector0 ...

  2. pyqt4学习笔记

    信号与槽机制 信号与槽机制作为Qt最重要的特性,提供了任意两个Qt对象之间的通信机制.其中,信号会在某个特定情况或动作下被触发,槽是用于接收并处理信号的函数.例如,要将一个窗口中的变化情况通知给另一个 ...

  3. C++学习注意点

    1.cin,cout关同步再用,不然效率很糟cin,cout关同步再用,不然效率很糟cin,cout关同步再用,不然效率很糟.重要的事情说三遍.关同步代码:std::ios::sync_with_st ...

  4. 使用时间戳和sequence生成主键的function

    create or replace function fn_getKeyreturn varchar2is  k varchar2(30);begin  select to_char(sysdate, ...

  5. GitHUb 代码提交遇到的问题以及解决办法

    git 添加代码出现以下错误: fatal: Unable to create 'F:/wamp/www/ThinkPhpStudy/.git/index.lock': File exists. If ...

  6. JPA，EclipseLink 缓存机制学习(一) 树节点搜索问题引发的思考

    最近在项目在使用JPA+EclipseLink 的方式进行开发,其中EclipseLink使用版本为2.5.1.遇到一些缓存方面使用不当造成的问题,从本篇开始逐步学习EclipseLink的缓存机制. ...

  7. ROWID伪列

    ROWID伪列概念: 在数据表中每一行所保存的记录,oracle会为每条记录分配一个唯一的地址编号,这个编号就是通过ROWID表示的. 所有的数据都利用ROWID进行定位. 观察rowid的存在 SQ ...

  8. angularjs不同页面间参数的传递

    1.在路由中定义要接收的参数 .state('userDetails', { url: '/userDetails?phone', //以?为标识接收参数 templateUrl: 'assets/v ...

  9. Java主函数定义

    public static void main(String[] args){} public: main主方法是由jvm来调用的,jvm实际也是一个程序,为了保证jvm能够在任何情况下来调用主函数. ...

  10. 为 iTween 指定特定的回调 : onupdate, oncomplete

    问题地址:Specifying a delegate for the value of onupdate in iTween 1.找到 void CallBack 2.修改以下代码: void Cal ...