java多线程synchronized用法

1. synchronized同步方法

方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前。

在两个线程访问同一对象中的同步方法时一定是线程安全的。

即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入。

public class MythreadA extends Thread{
    private MyObject object;
    public MythreadA(MyObject myObject) {
        super();
        this.object = myObject;
    }
    @Override
    public void run(){
        super.run();
        object.methodA();
    }
}

public class MythreadB extends Thread{
    private MyObject object;
    public MythreadB(MyObject myObject) {
        super();
        this.object = myObject;
    }
    @Override
    public void run(){
        super.run();
        object.methodB();
    }
}

public class MyObject {
    synchronized public void methodA() {
        try {
            System.out.println("beging methodA threadNanme = " +  Thread.currentThread().getName()
                    + " begin time=" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("end A endTime = " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    synchronized public void methodB() {
        try {
            System.out.println("begin methodB threadName=" + Thread.currentThread().getName()
            + " begin time=" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("end B endTime = " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            MyObject object = new MyObject();
            MythreadA a = new MythreadA(object);
            a.setName("A");
            MythreadB b = new MythreadB(object);
            b.setName("B");
            a.start();
            b.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

执行结果为：

如果把methodB的方法的synchronized去掉，那么，B线程可以异步调用此方法，结果为

synchronized取得的锁都是对象锁，所以，两个线程访问同一个类的两个不同对象的同步方法，结果却是异步的。

2. synchronized同步代码块

当两个并发的线程访问同一个object中的synchronized(this)同步代码块时，一段时间内只能由一个线程被执行，另一个线程必须等待当前线程执行完整个代码块之后，才能执行整个代码块。

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

public int synMethod(int a1){
   synchronized(a1) {
        //一次只能有一个线程进入
   }
}

synchronized后面括号里是一对象.例如

  public void run() {
    synchronized (this) {
      System.out.println(Thread.currentThread().getName());
    }
  }

对于方法块锁,如果线程进入,则得到当前对象锁,那么别的线程在对象上的任何操作都不能进行。

需要注意的是，如一个类对象中有两个方法，都用了synchronized (this)加锁，那么，当一个线程访问object的一个synchronized (this)同步块时，其他线程对同一个object中所有其他synchronized (this)的访问都被阻塞，如下代码：

同步执行结果如下：

synchronized是针对当前对象的，如果MethodA用的是synchronized(this)，MethodB使用的是synchronized方法，则两个方法对应同一对象来说，是同步的，执行MethodA后才会执行MethodB。

以上事例说明synchronized同步方法或synchronized同步代码块有两种作用

(1)synchronized同步方法

1. 对其他synchronized同步方法或synchronized(this)同步代码块调用呈阻塞状态

2. 同一时间只有一个线程可以执行synchronized同步方法中的代码

(2)synchronized(同步代码块)

1. 对其他synchronized同步方法或synchronized(this)同步代码块调用呈阻塞状态

2. 同一时间只有一个线程可以执行synchronized同步方法中的代码

在对象级使用锁通常是一种比较粗糙的方法。不要将整个对象都上锁，而

不允许其他线程短暂地使用对象中其他同步方法来访问共享资源。如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，可以如下所示使用虚拟对象来上锁：.

 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
   }
  }

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() {
    //
  }
  }

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

静态同步synchronized方法和synchronized(class)代码块

synchronized用在代码块上，是对当前java文件生成的class类进行持锁，synchronized加到非static静态方法上，是对对象进行加锁。例子如下：

执行结果为方法printC是异步的，而printA和printB是同步的。

synchronized(class)代码块和synchronized static是一样。

转载于：http://www.blogjava.net/konhon/archive/2005/08/17/10296.html