java synchronized关键字浅探

　　synchronized 是 java 多线程编程中用于使线程之间的操作串行化的关键字。这种措施类似于数据库中使用排他锁实现并发控制，但是有所不同的是，数据库中是对数据对象加锁，而 java 则是对将要执行的代码加锁。

在 java 中使用 synchronized 关键字时需要注意以下几点：

1.synchronized 是针对同一个资源的访问作出限制。这是出现该关键字的原因。

2.对于类而言，某一个线程执行到一个 synchronized 修饰的类方法或者类方法中的代码段时，该方法或者代码段就被加上互斥锁，同时该类中的所有使用 synchronized 修饰的类方法或者类方法中的代码段都被加上互斥锁，但不影响没有使用 synchronized 修饰的类方法或者类方法中的代码段，同时也不影响该线程执行这些剩余已经被加上锁的类方法或者类方法中的代码段以及其他类中的任意方法；当线程执行完被 synchronized 修饰的类方法或者类方法中的代码段后，这些互斥锁都将同时被释放。

3.对于对象而言，某一个线程执行到一个 synchronized 修饰的对象方法或者对象方法中的代码段时，情况和 2 中一样。

4. 第 3 点和第 2 点相互之间没有影响

5.synchronized() 括号内所使用的内容指示将要封锁的资源是一个类还是一个对象中的方法或者代码块。由于无法对类声明中使用 synchronized 修饰符，所以对于类而言，需要使用类似于 synchronized(ClassName.class){/*...*/} 形式或者使用 synchronized 修饰类方法

实例代码如下：

（1）Printer 类

 public class Printer {
     public static void printA()
     {
         System.out.println(Thread.currentThread() + ": invoke printA method");
         synchronized(Printer.class)
         {
             for(int i = 0; i < 5; i++)
             {
                 System.out.println(Thread.currentThread() + ": into printA method's loop...");
                 try
                 {
                     Thread.sleep(1000);
                 }
                 catch(InterruptedException e)
                 {
                     e.printStackTrace();
                 }
             }
         }
     }

     public synchronized void printB()
     {
         System.out.println(Thread.currentThread() + ": invoke printB method");
         for(int i = 0; i < 5; i++)
         {
             System.out.println(Thread.currentThread() + ": into printB method's loop...");
             try
             {
                 Thread.sleep(1000);
             }
             catch(InterruptedException e)
             {
                 e.printStackTrace();
             }
         }
     }
 }

（2）ThreadA 类

 package demo;

 public class ThreadA extends Thread{
     Printer p = null;
     public ThreadA(Printer p)
     {
         super("ThreadA");
         this.p = p;
     }
     public void run()
     {
         //p.printA();
         Printer.printA();
     }
 }

（3）ThreadB 类

 package demo;

 public class ThreadB extends Thread{
     Printer p = null;
     public ThreadB(Printer p)
     {
         super("ThreadB");
         this.p = p;
     }
     public void run()
     {
         //p.printB();
         Printer.printB();
     }
 }

（4）MainThread 类

 package demo;

 public class MainThread {
     public static void main(String[] args)
     {
         Printer p = new Printer();
         ThreadA ta = new ThreadA(p);
         ThreadB tb = new ThreadB(p);

         ta.start();
         try {
             ta.join(10);
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         tb.start();
     }
 }

运行结果如下：

Thread[ThreadA,5,main]: invoke printA method
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadB,5,main]: invoke printB method
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadB,5,main]: into printB method's loop...

从上述结果可以看出，ThreadA 首先调用 run 方法，并且进入了 printA 方法的 for 循环块，因此先获得了互斥锁；根据 2 即可得知 ThreadB 无法执行 printB 方法。在 MainThread 中加上 join(10) 为了给 ThreadA 更多的时间以便于让它能先进入 printA 方法（这是因为 ThreadA 需要在执行完一条 pirnt 语句之后才能获得互斥锁）。如果去掉 join 语句即可验证该点。

在上述的 Printer 类添加一个 printC 方法：

     public void printC()
     {
         System.out.println(Thread.currentThread() + ": invoke printC method");
     }

创建一个 ThreadC 类：

 package demo;

 public class ThreadC extends Thread{
     Printer p = null;
     public ThreadC(Printer p)
     {
         this.p = p;
     }
     public void run()
     {
         for(int i = 0; i < 5; i++)
         {
             p.printC();
         }
     }
 }

然后在 MainThread 中去掉 join 语句，激活线程 ThreadC，运行结果如下(各位测试时结果可能有所不同)：

Thread[Thread-0,5,main]: invoke printC method
Thread[ThreadA,5,main]: invoke printA method
Thread[Thread-0,5,main]: invoke printC method
Thread[Thread-0,5,main]: invoke printC method
Thread[ThreadB,5,main]: invoke printB method
Thread[ThreadB,5,main]: into printB method's loop...
Thread[Thread-0,5,main]: invoke printC method
Thread[Thread-0,5,main]: invoke printC method
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadA,5,main]: into printA method's loop...

对于上述结果，大家可以结合 2 自己进行解释，对于 2 中剩余的观点以及对于对象的情况，也可以自行测试验证。下面验证 4 。

将 Printer 方法中的 printB 方法声明中的 static 关键字去掉，在 ThreadB 类 run 方法中使用 p.printB() 替换 Printer.printB() ，运行结果如下：

Thread[ThreadA,5,main]: invoke printA method
Thread[ThreadB,5,main]: invoke printB method
Thread[ThreadB,5,main]: into printB method's loop...
Thread[Thread-0,5,main]: invoke printC method
Thread[ThreadA,5,main]: into printA method's loop...
Thread[Thread-0,5,main]: invoke printC method
Thread[Thread-0,5,main]: invoke printC method
Thread[Thread-0,5,main]: invoke printC method
Thread[Thread-0,5,main]: invoke printC method
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadA,5,main]: into printA method's loop...
Thread[ThreadB,5,main]: into printB method's loop...
Thread[ThreadA,5,main]: into printA method's loop...

对于输出结果，各位看官可以细心分析分析

（未完待续。。。;-)）

本文有参考：Devin Zhang 的博客