java中synchronized的用法

       在java程序设计中,synchronized共有4种用法，分别是在方法声明时使用、对某一代码块使用、synchronized后面括号里是一对象、synchronized后面括号里是类。

     1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入。

      例如:

      public synchronized void synMethod() {

        //方法体

      }

    2.对某一代码块使用,synchronized后跟括号,括号里是变量,这样,一次只有一个线程进入该代码块。

    例如:

      public int synMethod(int a){

        synchronized(a) {

          //一次只能有一个线程进入

        }

      }

    3.synchronized后面括号里是一对象,此时线程获得的是对象锁。

       例如:

        public class MyThread implements Runnable {

           public static void main(String args[]) {

            MyThread mt = new MyThread();

            Thread t1 = new Thread(mt, "t1");

            Thread t2 = new Thread(mt, "t2");

            Thread t3 = new Thread(mt, "t3");

            Thread t4 = new Thread(mt, "t4");

            Thread t5 = new Thread(mt, "t5");

            Thread t6 = new Thread(mt, "t6");

            t1.start();

            t2.start();

            t3.start();

            t4.start();

            t5.start();

            t6.start();

      } 

     public void run() {

       synchronized (this) {

           System.out.println(Thread.currentThread().getName());

         }

       }

     }

      对于3,如果线程进入,则得到对象锁,那么别的线程在该类所有对象上的任何操作都不能进行.在对象级使用锁通常是一种比较粗糙的方法。为什么要将整个对象都上锁，而不允许其他线程短暂地使用对象中其他同步方法来访问共享资源？如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，可以如下所示使用虚拟对象来上锁：

    class FineGrainLock {

      MyMemberClass x, y;

      Object xlock = new Object(), ylock = new Object();

      public void foo() {

          synchronized(xlock) {

            //access x here

         }

         //do something here - but don't use shared resources

         synchronized(ylock) {

            //access y here

        }

      }

      public void bar() {

         synchronized(this) {

           //access both x and y here

        }

        //do something here - but don't use shared resources

       }

   }

4.synchronized后面括号里是类。

   class ArrayWithLockOrder{

        private static long num_locks = 0;

        private long lock_order;

        private int[] arr;

        public ArrayWithLockOrder(int[] a)

        {

             arr = a;

             synchronized(ArrayWithLockOrder.class) {//-----------------------------------------这里

             num_locks++;             // 锁数加 1。

             lock_order = num_locks;  // 为此对象实例设置唯一的 lock_order。

          }

        }

       public long lockOrder()

       {

            return lock_order;

        }

       public int[] array()

       {

             return arr;

        }

      }

     class SomeClass implements Runnable

     {

          public int sumArrays(ArrayWithLockOrder a1, ArrayWithLockOrder a2)

         {

            int value = 0;

            ArrayWithLockOrder first = a1;       // 保留数组引用的一个

            ArrayWithLockOrder last = a2;        // 本地副本。

            int size = a1.array().length;

            if (size == a2.array().length)
  
            {

               if (a1.lockOrder() > a2.lockOrder())  // 确定并设置对象的锁定

               {                                     // 顺序。

                   first = a2;

                   last = a1;

              }

            synchronized(first) {              // 按正确的顺序锁定对象。
   
                synchronized(last) {

                   int[] arr1 = a1.array();

         	   int[] arr2 = a2.array();

       		   for (int i=0; i<size; i++)

         	   value += arr1[i] + arr2[i];

                }

            }

        }
   
         return value;

    }

      public void run() {

    //...

        }

   }

例如:

     对于4,如果线程进入,则线程在该类中所有操作不能进行,包括静态变量和静态方法,实际上,对于含有静态方法和静态变量的代码块的同步,我们通常用4来加锁.

总结：以上4种之间的关系：

     锁是和对象相关联的，每个对象有一把锁，为了执行synchronized语句，线程必须能够获得synchronized语句中表达式指定的对象的锁，一个对象只有一把锁，被一个线程获得之后它就不再拥有这把锁，线程在执行完synchronized语句后，将获得锁交还给对象。

     在方法前面加上synchronized修饰符即可以将一个方法声明为同步化方法。同步化方法在执行之前获得一个锁。如果这是一个类方法，那么获得的锁是和声明方法的类相关的Class类对象的锁。如果这是一个实例方法，那么此锁是this对象的锁。