synchronized修饰方法和修饰方法块（二）

synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。 　　1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如： 　　public synchronized void accessVal(int newVal); 　　synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能
执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行
状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有
一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）
。 　　在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成
员变量的访问。 　　synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为
synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可
以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供
了更好的解决办法，那就是 synchronized 块。 　　2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下： 　　synchronized(syncObject) { 　　//允许访问控制的代码 　　} 　　 synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机
制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。 　　对synchronized(this)的一些理解　　一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线
程必须等待当前线程执行完这个代码块以后才能执行该代码块。 　　二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized
(this)同步代码块。 　　三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)
同步代码块的访问将被阻塞。 　　四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个
object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。 　　五、以上规则对其它对象锁同样适用总结：synchronized是对象锁，不是方法锁，在多线程中只能对当前对象锁，当出现第二个实例对象时，对之前的对象是不起作用的

public class Thread3 {     class Inner {          private  synchronized void m4t1() {               int i = 5;               while(i-- > 0) {                    System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);                    try {                         Thread.sleep(500);                    } catch(InterruptedException ie) {                    }               }          }          private synchronized void m4t2() {               int i = 5;               while(i-- > 0) {                    System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);                    try {                         Thread.sleep(500);                    } catch(InterruptedException ie) {                    }               }          }     }     private void m4t1(Inner inner) {          synchronized (inner) { //使用对象锁               inner.m4t1();          }     }      private void m4t2(Inner inner) {          inner.m4t2();     }         public static void main(String[] args) {          final Thread3 myt3 = new Thread3();          final Inner inner = myt3.new Inner();          final Inner inner1 = myt3.new Inner();          Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1");          //只对当前对象加锁，必须 是同一对象锁才有用          Thread t2 = new Thread( new Runnable() {public void run() { myt3.m4t2(inner1);} }, "t2");     t1.start();     t2.start();  }}
t1 : Inner.m4t1()=4t2 : Inner.m4t2()=4t1 : Inner.m4t1()=3t2 : Inner.m4t2()=3t2 : Inner.m4t2()=2t1 : Inner.m4t1()=2t2 : Inner.m4t2()=1t1 : Inner.m4t1()=1t1 : Inner.m4t1()=0t2 : Inner.m4t2()=0所以在多系统开发中，synchronized是没用的（来自其他系统操作数据库）最佳实践：在多模块/多系统的开发中，1.数据库的悲观锁，比如行锁2.数据库的乐观锁，代码层面的乐观锁不行（来自其他系统操作数据库），把乐观锁放在数据库的存储过程中参考http://blog.csdn.net/wangdonghello/article/details/38259273