java同步方法和同步代码块的区别

最新推荐文章于 2023-05-14 11:19:43 发布
最新推荐文章于 2023-05-14 11:19:43 发布
阅读量2w 收藏 10
点赞数 2
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feier7501/article/details/22096915
版权

同步代码块：

package threads.ex1;

class KitchenSync {
	private int[] intArray = new int[10];

	void reverseOrder() {
		synchronized (this) {
			int halfWay = intArray.length / 2;
			for (int i = 0; i < halfWay; ++i) {
				int upperIndex = intArray.length - 1 - i;
				int save = intArray[upperIndex];
				intArray[upperIndex] = intArray[i];
				intArray[i] = save;
			}
		}
	}
}


反编译后的字节码：

E:\Java\code\jvm\bin\threads\ex1>javap -verbose KitchenSync
Compiled from "KitchenSync.java"
class threads.ex1.KitchenSync extends java.lang.Object
  SourceFile: "KitchenSync.java"
  minor version: 0
  major version: 50
  Constant pool:
const #1 = class        #2;     //  threads/ex1/KitchenSync
const #2 = Asciz        threads/ex1/KitchenSync;
const #3 = class        #4;     //  java/lang/Object
const #4 = Asciz        java/lang/Object;
const #5 = Asciz        intArray;
const #6 = Asciz        [I;
const #7 = Asciz        <init>;
const #8 = Asciz        ()V;
const #9 = Asciz        Code;
const #10 = Method      #3.#11; //  java/lang/Object."<init>":()V
const #11 = NameAndType #7:#8;//  "<init>":()V
const #12 = Field       #1.#13; //  threads/ex1/KitchenSync.intArray:[I
const #13 = NameAndType #5:#6;//  intArray:[I
const #14 = Asciz       LineNumberTable;
const #15 = Asciz       LocalVariableTable;
const #16 = Asciz       this;
const #17 = Asciz       Lthreads/ex1/KitchenSync;;
const #18 = Asciz       reverseOrder;
const #19 = Asciz       halfWay;
const #20 = Asciz       I;
const #21 = Asciz       i;
const #22 = Asciz       upperIndex;
const #23 = Asciz       save;
const #24 = Asciz       StackMapTable;
const #25 = class       #26;    //  java/lang/Throwable
const #26 = Asciz       java/lang/Throwable;
const #27 = Asciz       SourceFile;
const #28 = Asciz       KitchenSync.java;

{
threads.ex1.KitchenSync();
  Code:
   Stack=2, Locals=1, Args_size=1
   0:   aload_0
   1:   invokespecial   #10; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   bipush  10
   7:   newarray int
   9:   putfield        #12; //Field intArray:[I
   12:  return
  LineNumberTable:
   line 3: 0
   line 4: 4
   line 3: 12

  LocalVariableTable:
   Start  Length  Slot  Name   Signature
   0      13      0    this       Lthreads/ex1/KitchenSync;


void reverseOrder();
  Code:
   Stack=4, Locals=6, Args_size=1
   0:   aload_0
   1:   dup
   2:   astore_1
   3:   monitorenter
   4:   aload_0
   5:   getfield        #12; //Field intArray:[I
   8:   arraylength
   9:   iconst_2
   10:  idiv
   11:  istore_2
   12:  iconst_0
   13:  istore_3
   14:  goto    61
   17:  aload_0
   18:  getfield        #12; //Field intArray:[I
   21:  arraylength
   22:  iconst_1
   23:  isub
   24:  iload_3
   25:  isub
   26:  istore  4
   28:  aload_0
   29:  getfield        #12; //Field intArray:[I
   32:  iload   4
   34:  iaload
   35:  istore  5
   37:  aload_0
   38:  getfield        #12; //Field intArray:[I
   41:  iload   4
   43:  aload_0
   44:  getfield        #12; //Field intArray:[I
   47:  iload_3
   48:  iaload
   49:  iastore
   50:  aload_0
   51:  getfield        #12; //Field intArray:[I
   54:  iload_3
   55:  iload   5
   57:  iastore
   58:  iinc    3, 1
   61:  iload_3
   62:  iload_2
   63:  if_icmplt       17
   66:  aload_1
   67:  monitorexit
   68:  goto    74
   71:  aload_1
   72:  monitorexit
   73:  athrow
   74:  return
  Exception table:
   from   to  target type
     4    68    71   any
    71    73    71   any
  LineNumberTable:
   line 7: 0
   line 8: 4
   line 9: 12
   line 10: 17
   line 11: 28
   line 12: 37
   line 13: 50
   line 9: 58
   line 7: 66
   line 16: 74

  LocalVariableTable:
   Start  Length  Slot  Name   Signature
   0      75      0    this       Lthreads/ex1/KitchenSync;
   12      54      2    halfWay       I
   14      52      3    i       I
   28      30      4    upperIndex       I
   37      21      5    save       I

  StackMapTable: number_of_entries = 4
   frame_type = 254 /* append */
     offset_delta = 17
     locals = [ class threads/ex1/KitchenSync, int, int ]
   frame_type = 43 /* same */
   frame_type = 255 /* full_frame */
     offset_delta = 9
     locals = [ class threads/ex1/KitchenSync, class threads/ex1/KitchenSync ]
     stack = [ class java/lang/Throwable ]
   frame_type = 250 /* chop */
     offset_delta = 2


}

分析

方法内的同步语句会使用两个指令：

monitorenterc2 objectref →enter monitor for object ("grab the lock" - start of synchronized() section)
monitorexitc3 objectref →exit monitor for object ("release the lock" - end of synchronized() section)

当java虚拟机遇到monitorenter的时候，它获得栈中objectref所引用的对象的锁。如果线程已经拥有了那个对象的锁，锁的计数器会加1。线程中每条monitorexit指令都会引起计数器减1。当计数器变成0的时候，监视器就释放了。

而且return后，还有Exception table。


同步方法：

package threads.ex1;

class HeatSync {
	private int[] intArray = new int[10];

	synchronized void reverseOrder() {
		int halfWay = intArray.length / 2;
		for (int i = 0; i < halfWay; ++i) {
			int upperIndex = intArray.length - 1 - i;
			int save = intArray[upperIndex];
			intArray[upperIndex] = intArray[i];
			intArray[i] = save;
		}
	}
}

反编译后的字节码：

E:\Java\code\jvm\bin\threads\ex1>javap -verbose HeatSync
Compiled from "HeatSync.java"
class threads.ex1.HeatSync extends java.lang.Object
  SourceFile: "HeatSync.java"
  minor version: 0
  major version: 50
  Constant pool:
const #1 = class        #2;     //  threads/ex1/HeatSync
const #2 = Asciz        threads/ex1/HeatSync;
const #3 = class        #4;     //  java/lang/Object
const #4 = Asciz        java/lang/Object;
const #5 = Asciz        intArray;
const #6 = Asciz        [I;
const #7 = Asciz        <init>;
const #8 = Asciz        ()V;
const #9 = Asciz        Code;
const #10 = Method      #3.#11; //  java/lang/Object."<init>":()V
const #11 = NameAndType #7:#8;//  "<init>":()V
const #12 = Field       #1.#13; //  threads/ex1/HeatSync.intArray:[I
const #13 = NameAndType #5:#6;//  intArray:[I
const #14 = Asciz       LineNumberTable;
const #15 = Asciz       LocalVariableTable;
const #16 = Asciz       this;
const #17 = Asciz       Lthreads/ex1/HeatSync;;
const #18 = Asciz       reverseOrder;
const #19 = Asciz       halfWay;
const #20 = Asciz       I;
const #21 = Asciz       i;
const #22 = Asciz       upperIndex;
const #23 = Asciz       save;
const #24 = Asciz       StackMapTable;
const #25 = Asciz       SourceFile;
const #26 = Asciz       HeatSync.java;

{
threads.ex1.HeatSync();
  Code:
   Stack=2, Locals=1, Args_size=1
   0:   aload_0
   1:   invokespecial   #10; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   bipush  10
   7:   newarray int
   9:   putfield        #12; //Field intArray:[I
   12:  return
  LineNumberTable:
   line 3: 0
   line 4: 4
   line 3: 12

  LocalVariableTable:
   Start  Length  Slot  Name   Signature
   0      13      0    this       Lthreads/ex1/HeatSync;


synchronized void reverseOrder();
  Code:
   Stack=4, Locals=5, Args_size=1
   0:   aload_0
   1:   getfield        #12; //Field intArray:[I
   4:   arraylength
   5:   iconst_2
   6:   idiv
   7:   istore_1
   8:   iconst_0
   9:   istore_2
   10:  goto    54
   13:  aload_0
   14:  getfield        #12; //Field intArray:[I
   17:  arraylength
   18:  iconst_1
   19:  isub
   20:  iload_2
   21:  isub
   22:  istore_3
   23:  aload_0
   24:  getfield        #12; //Field intArray:[I
   27:  iload_3
   28:  iaload
   29:  istore  4
   31:  aload_0
   32:  getfield        #12; //Field intArray:[I
   35:  iload_3
   36:  aload_0
   37:  getfield        #12; //Field intArray:[I
   40:  iload_2
   41:  iaload
   42:  iastore
   43:  aload_0
   44:  getfield        #12; //Field intArray:[I
   47:  iload_2
   48:  iload   4
   50:  iastore
   51:  iinc    2, 1
   54:  iload_2
   55:  iload_1
   56:  if_icmplt       13
   59:  return
  LineNumberTable:
   line 7: 0
   line 8: 8
   line 9: 13
   line 10: 23
   line 11: 31
   line 12: 43
   line 8: 51
   line 14: 59

  LocalVariableTable:
   Start  Length  Slot  Name   Signature
   0      60      0    this       Lthreads/ex1/HeatSync;
   8      52      1    halfWay       I
   10      49      2    i       I
   23      28      3    upperIndex       I
   31      20      4    save       I

  StackMapTable: number_of_entries = 2
   frame_type = 253 /* append */
     offset_delta = 13
     locals = [ int, int ]
   frame_type = 40 /* same */


}

分析

可以看到，同步方法没有使用monitorenter和monitorexit这两个指令。

方法return后也没有Exception table。

当虚拟机解析对方法的符号引用时，它判断这个方法是否是同步的。如果是同步的，虚拟机就在调用方法之前获取一个锁。


总结

因此，同步方法比同步代码块更高效，但是它们的功能是一样的。

feier7501
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
java 中同步方法和同步代码块的区别详解
08-31
主要介绍了java 中同步方法和同步代码块的区别是什么的相关资料,需要的朋友可以参考下
【java】java实现同步方式
最新发布
DreamSun的博客
05-21 3663
避免多线程数据不一致，java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，不被其他线程的调用，从而保证了该变量的唯一性和准确性。
Java 实现同步的几种方式
u011035026的博客
03-01 1万+
1、Java 实现同步的几种方式 使用 synchronized 关键字 使用 ReentrantLock（可重入锁）以及 Condition。 使用 java.util.concurrent.atomic 包中提供的类，如 AtomicInteger 等，能够实现多个线程对该类型的数据操作时的原子性（相当于保证线程间获取的到数据是最新的）。这些类的实现，主要通过使用 volatile 来修饰属性。 并发包下的工具类，分别有： （1）CountDownLatch： 允许一个或多个线程等待其他线程完成操作。
Java 中同步机制的几种方式及使用
IT徐师兄
05-14 3039
Java 中同步机制的几种方式及使用
java实现同步的几种方式（总结）
qq_21810059的博客
08-11 5366
1.同步方法 即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。 代码如： public synchronized void save(){} 注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类 public class Bank { private int count =0;//账户余额 //
JAVA 同步方法和同步代码块的区别是什么？
热门推荐
疯
06-04 1万+
区别： 同步方法默认用this或者当前类class对象作为锁； 同步代码块可以选择以什么来加锁，比同步方法要更细颗粒度，我们可以选择只同步会发生同步问题的部分代码而不是整个方法； 同步方法使用关键字 synchronized修饰方法，而同步代码块主要是修饰需要进行同步的代码，用 synchronized（object）{代码内容}进行修饰； 为何使用同步？ java允许多线程并发控制，当多个线...
java中synchronized（同步代码块和同步方法）详解及区别
08-31
主要介绍了 java中synchronized（同步代码块和同步方法）详解及区别的相关资料,需要的朋友可以参考下
Java同步代码块和同步方法原理与应用案例详解
08-25
主要介绍了Java同步代码块和同步方法原理与应用,结合具体案例形式分析了使用java同步代码块和同步方法实现买票功能的相关原理与操作技巧,需要的朋友可以参考下
java使用datax增量同步代码
04-19
java使用datax增量同步代码，直接放到项目可使用，支持增量，全量可配置，同步一张表只需添加一条记录
同步代码块(synchronized).zip
03-22
【Java基础知识 第四节 多线程复习】中，同步代码块(synchronized关键字)的两个练习代码。
多线程的安全问题一:同步方法与同步代码块
Groot-lin的博客
11-10 548
多线程的安全问题及解决方式(解决Runnable方式及Thread方式)
Java基础学习——Java线程（二）同步代码块、同步方法、Lock锁、死锁程序例子、不同类型的锁
skx1102195517的博客
12-30 1984
1
同步方法和同步代码块的区别
I8008208820的博客
11-17 2731
同步方法和同步代码块的区别
【第八章 线程的同步机制（同步代码块、同步方法）】
qq_43742813的博客
09-13 543
第八章 线程的同步机制（同步代码块、同步方法）
JAVA同步代码块 & 同步方法
DoubleQ的博客
02-12 1669
为了解决多线程操作共享数据时产生的安全问题例如以下代码如果两个线程同时执行以上方法，同时访问或修改共享的变量ticket，就有可能会出现安全问题。
Java中的同步方法
weixin_44431508的博客
09-07 562
Java中的同步方法 一、Synchronized Synchronized是JAVA中的关键字，是语言层面的互斥锁。它可以修饰以下对象： 修饰代码块，被修饰的代码块称为同步语句块，其作用范围即大括号{}括起来的代码，作用的对象是调用这个代码块的对象。保证最多只有一个线程能够允许该代码块。 修饰一个方法，被称为同步方法，作用范围为整个方法，作用的对象是调用这个代码块的对象。 修饰一个类，作用范围是整个类。作用的对象是该类所有实例。 二、ReentrantLock ReentrantLock是API层面的
同步代码块与同步方法
zzd的博客
04-13 1007
在Java中，我们通过同步机制，来解决线程的安全问题。 方式一：同步代码块 synchronized(同步监视器){ //需要被同步的代码 } 1.操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。 2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。 3.同步监视器，...
Java线程同步的四种方式详解(建议收藏)
mikechen的互联网架构
09-28 1501
Java线程同步属于Java多线程与并发编程的核心点，需要重点掌握，下面我就来详解Java线程同步的4种主要的实现方式@mikechen
java同步方法
weixin_45966674的博客
12-03 300
观看此文 首先 你要了解 java的同步锁如果不了解 可以观看我的文章 java 同步锁synchronized 解决线程共享数据重复操作问题 那么 从下图 我们可以看到 逻辑代码上被绑了一个同步锁但这个其实大可以写成一个函数 看起来会美观便捷很多同步方法的格式如下 修饰符 synchronized 方法名 这里我们定义了work 为一个同步方法 让他去执行同步锁内的方法不过要记住同步锁都需要一个对象来做锁定 而 同步方法 所选择的 是this所以 当你要把另一个同步锁和
java同步代码块和同步方法的区别
04-29
Java中的同步代码块和同步方法都是用来保证多线程环境下数据的安全性和一致性，避免线程间的竞态条件和数据冲突。 同步代码块是指通过synchronized关键字对一段代码块进行加锁，使得同一时刻只有一个线程可以进入该...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值