java锁:synchronized_Allione_新浪博客

本文深入探讨Java中的同步机制,包括synchronized关键字的使用方法、作用原理及其实现机制。介绍了对象锁与类锁的区别,通过实例展示了如何在实例方法、静态方法及方法内部实现同步,确保线程安全。

原理:

代码块同步是使用monitorenter和monitorexit指令实现,而方法同步是使用另外一种方式实现的,细节在JVM规范里并没有详细说明,但是方法的同步同样可以使用这两个指令来实现。monitorenter指令是在编译后插入到同步代码块的开始位置,而monitorexit是插入到方法结束处和异常处, JVM要保证每个monitorenter必须有对应的monitorexit与之配对。任何对象都有一个 monitor 与之关联,当且一个monitor 被持有后,它将处于锁定状态。线程执行到 monitorenter 指令时,将会尝试获取对象所对应的 monitor 的所有权,即尝试获得对象的锁。

 Java对象头

锁存在Java对象头里。如果对象是数组类型,则虚拟机用3个Word(字宽)存储对象头,如果对象是非数组类型,则用2字宽存储对象头。在32位虚拟机中,一字宽等于四字节,即32bit。


1、synchronized:所有对象都自动含有单一的锁(监视器),但在对象上调用其任意synchronized方法的时候,此对象都被加锁,这是该对象上的其他synchronized方法只有等到前一个方法调用完毕并释放了锁之后才能被调用,Java中的同步块用synchronized标记。同步块在Java中是同步在某个对象上。所有同步在一个对象上的同步块在同时只能被一个线程进入并执行操作。所有其他等待进入该同步块的线程将被阻塞,直到执行该同步块中的线程退出。

1)​  实例方法同步

下面是一个同步的实例方法:

public synchronized void add(int value){

this.count += value;

 }

注意在方法声明中同步(synchronized )关键字。这告诉Java该方法是同步的。

Java实例方法同步是同步在拥有该方法的对象上。这样,每个实例其方法同步都同步在不同的对象上,即该方法所属的实例。只有一个线程能够在实例方法同步块中运行。如果有多个实例存在,那么一个线程一次可以在一个实例同步块中执行操作。一个实例一个线程。

2)  ​静态方法同步

静态方法同步和实例方法同步方法一样,也使用synchronized 关键字。Java静态方法同步如下示例:

public static synchronized void add(int value){

 count += value;

 }

同样,这里synchronized 关键字告诉Java这个方法是同步的。

静态方法的同步是指同步在该方法所在的类对象上(与类实例不同)。因为在Java虚拟机中一个类只能对应一个类对象,所以同时只允许一个线程执行同一个类中的静态同步方法

对于不同类中的静态同步方法,一个线程可以执行每个类中的静态同步方法而无需等待。不管类中的哪个静态同步方法被调用,一个类只能由一个线程同时执行。

3)实例方法中的同步块

有时你不需要同步整个方法,而是同步方法中的一部分。Java可以对方法的一部分进行同步。

在非同步的Java方法中的同步块的例子如下所示:

public void add(int value){

    synchronized(this){

       this.count += value;

    }

  }

示例使用Java同步块构造器来标记一块代码是同步的。该代码在执行时和同步方法一样。

​注意Java同步块构造器用括号将对象括起来。在上例中,使用了“this”,即为调用add方法的实例本身。在同步构造器中用括号括起来的对象叫做监视器对象。上述代码使用监视器对象同步,同步实例方法使用调用方法本身的实例作为监视器对象。

一次只有一个线程能够在同步于同一个监视器对象的Java方法内执行。

下面两个例子都同步他们所调用的实例对象上,因此他们在同步的执行效果上是等效的。

public class MyClass {

   public synchronized void log1(String msg1, String msg2){//同步方法

      log.writeln(msg1);

      log.writeln(msg2);

   }

   public void log2(String msg1, String msg2){

      synchronized(this){//同步块

         log.writeln(msg1);

         log.writeln(msg2);

      }   }

在上例中,每次只有一个线程能够在两个同步块中任意一个方法内执行。

如果第二个同步块不是同步在this实例对象上,那么两个方法可以被线程同时执行。

4)​静态方法中的同步块

和上面类似,下面是两个静态方法同步的例子。这些方法同步在该方法所属的类对象上。

public class MyClass {

    public static synchronized void log1(String msg1, String msg2){//静态同步方法

       log.writeln(msg1);

       log.writeln(msg2);

    }

    public static void log2(String msg1, String msg2){

       synchronized(MyClass.class){//静态同步方法,以class对象为同步

          log.writeln(msg1);

          log.writeln(msg2);

       }    }  }

这两个方法不允许同时被线程访问。如果第二个同步块不是同步在MyClass.class这个对象上。那么这两个方法可以同时被线程访问。

2、对象锁与类锁

对象锁是用于对象实例方法,或者一个对象实例上的,类锁是用于类的静态方法或者一个类的class对象上的。我们知道,类的对象实例可以有很多个,但是每个类只有一个class对象,所以不同对象实例的对象锁是互不干扰的,但是每个类只有一个类锁。但是有一点必须注意的是,其实类锁只是一个概念上的东西,并不是真实存在的,它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

3、Java同步实例

在下面例子中,启动了两个线程,都调用Counter类同一个实例的add方法。因为同步在该方法所属的实例上,所以同时只能有一个线程访问该方法。

public class Counter{

     long count = 0;

     public synchronized void add(long value){//同步在方法所属的实例上

       this.count += value;

     }  }

  public class CounterThread extends Thread{

     protected Counter counter = null;

     public CounterThread(Counter counter){

        this.counter = counter;

     }

     public void run() {

    for(int i=0; i<10; i++){

           counter.add(i);

        }     }  }

  public class Example {

    public static void main(String[] args){

      Counter counter = new Counter();

      Thread  threadA = new CounterThread(counter);

      Thread  threadB = new CounterThread(counter);

      threadA.start();

      threadB.start();//两个线程公用同一个实例对象,两个线程并发执行,但是只允许一                                    个线程调用该方法。

    }  }

创建了两个线程。他们的构造器引用同一个Counter实例。Counter.add方法是同步在实例上,是因为add方法是实例方法并且被标记上synchronized关键字。因此每次只允许一个线程调用该方法。另外一个线程必须要等到第一个线程退出add()方法时,才能继续执行方法。

如果两个线程引用了两个不同的Counter实例,那么他们可以同时调用add()方法。这些方法调用了不同的对象,因此这些方法也就同步在不同的对象上。这些方法调用将不会被阻塞。如下面这个例子所示:

public class Example {

   public static void main(String[] args){

     Counter counterA = new Counter();

     Counter counterB = new Counter();

     Thread  threadA = new CounterThread(counterA);

  Thread  threadB = new CounterThread(counterB);//线程A、B执行不同的对象实例。

     threadA.start();

     threadB.start();

   } }

注意这两个线程,threadA和threadB,不再引用同一个counter实例。CounterA和counterB的add方法同步在他们所属的对象上。调用counterA的add方法将不会阻塞调用counterB的add方法。

 

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值