Lock与synchronized 的区别

1、ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 锁投票，定时锁等候和中断锁等候

线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定，

如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断

如果
使用ReentrantLock，如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情

ReentrantLock获取锁定与三种方式：
    a) 
lock(), 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁

b)
tryLock(), 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；

c)tryLock(long timeout,TimeUnit unit)，   如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；

d)
lockInterruptibly:如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断

2、synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异
常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中

3、在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态；

下面内容 是转载 http://zzhonghe.iteye.com/blog/826162

5.0的多线程任务包对于同步的性能方面有了很大的改进，在原有synchronized关键字的基础上，又增加了ReentrantLock，以及各种Atomic类。了解其性能的优劣程度，有助与我们在特定的情形下做出正确的选择。


总体的结论先摆出来： 

synchronized：

在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好，不管用没用过5.0多线程包的程序员都能理解。


ReentrantLock:
ReentrantLock
提供了多样化的同步，比如有时间限制的同步，可以被Interrupt的同步（synchronized的同步是不能Interrupt的）等。在资源竞
争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍。而
ReentrantLock确还能维持常态。

Atomic:
和上面的类似，不激烈情况下，性能比synchronized略
逊，而激烈的时候，也能维持常态。激烈的时候，Atomic的性能会优于ReentrantLock一倍左右。但是其有一个缺点，就是只能同步一个值，一
段代码中只能出现一个Atomic的变量，多于一个同步无效。因为他不能在多个Atomic之间同步。


所以，我们写同步的时候，优先考虑synchronized，如果有特殊需要，再进一步优化。ReentrantLock和Atomic如果用的不好，不仅不能提高性能，还可能带来灾难。


先贴测试结果：再贴代码（Atomic测试代码不准确，一个同步中只能有1个Actomic，这里用了2个，但是这里的测试只看速度）

==========================
round:100000 thread:5
Sync = 35301694

Lock = 56255753
Atom = 43467535
==========================

round:200000 thread:10
Sync = 110514604
Lock = 204235455
Atom =
170535361
==========================
round:300000 thread:15
Sync =
253123791
Lock = 448577123
Atom = 362797227

==========================
round:400000 thread:20
Sync = 16562148262

Lock = 846454786
Atom = 667947183
==========================

round:500000 thread:25
Sync = 26932301731
Lock = 1273354016
Atom
= 982564544

代码如下：

Java代码  

    1. package test.thread;

    2. import static java.lang.System.out;

    3. import java.util.Random;

    4. import java.util.concurrent.BrokenBarrierException;

    5. import java.util.concurrent.CyclicBarrier;

    6. import java.util.concurrent.ExecutorService;

    7. import java.util.concurrent.Executors;

    8. import java.util.concurrent.atomic.AtomicInteger;

    9. import java.util.concurrent.atomic.AtomicLong;

    10. import java.util.concurrent.locks.ReentrantLock;

    11. public class TestSyncMethods {

    12. public static void test(int round,int threadNum,CyclicBarrier cyclicBarrier){

    13. new SyncTest("Sync",round,threadNum,cyclicBarrier).testTime();

    14. new LockTest("Lock",round,threadNum,cyclicBarrier).testTime();

    15. new AtomicTest("Atom",round,threadNum,cyclicBarrier).testTime();

    16. }

    17. public static void main(String args[]){

    18. for(int i=0;i<5;i++){

    19. int round=100000*(i+1);

    20. int threadNum=5*(i+1);

    21. CyclicBarrier cb=new CyclicBarrier(threadNum*2+1);

    22. out.println("==========================");

    23. out.println("round:"+round+" thread:"+threadNum);

    24. test(round,threadNum,cb);

    25. }

    26. }

    27. }

    28. class SyncTest extends TestTemplate{

    29. public SyncTest(String _id,int _round,int _threadNum,CyclicBarrier _cb){

    30. super( _id, _round, _threadNum, _cb);

    31. }

    32. @Override

    33. /**

    34. * synchronized关键字不在方法签名里面，所以不涉及重载问题

    35. */

    36. synchronized long  getValue() {

    37. return super.countValue;

    38. }

    39. @Override

    40. synchronized void  sumValue() {

    41. super.countValue+=preInit[index++%round];

    42. }

    43. }

    44. class LockTest extends TestTemplate{

    45. ReentrantLock lock=new ReentrantLock();

    46. public LockTest(String _id,int _round,int _threadNum,CyclicBarrier _cb){

    47. super( _id, _round, _threadNum, _cb);

    48. }

    49. /**

    50. * synchronized关键字不在方法签名里面，所以不涉及重载问题

    51. */

    52. @Override

    53. long getValue() {

    54. try{

    55. lock.lock();

    56. return super.countValue;

    57. }finally{

    58. lock.unlock();

    59. }

    60. }

    61. @Override

    62. void sumValue() {

    63. try{

    64. lock.lock();

    65. super.countValue+=preInit[index++%round];

    66. }finally{

    67. lock.unlock();

    68. }

    69. }

    70. }

    71. class AtomicTest extends TestTemplate{

    72. public AtomicTest(String _id,int _round,int _threadNum,CyclicBarrier _cb){

    73. super( _id, _round, _threadNum, _cb);

    74. }

    75. @Override

    76. /**

    77. * synchronized关键字不在方法签名里面，所以不涉及重载问题

    78. */

    79. long  getValue() {

    80. return super.countValueAtmoic.get();

    81. }

    82. @Override

    83. void  sumValue() {

    84. super.countValueAtmoic.addAndGet(super.preInit[indexAtomic.get()%round]);

    85. }

    86. }

    87. abstract class TestTemplate{

    88. private String id;

    89. protected int round;

    90. private int threadNum;

    91. protected long countValue;

    92. protected AtomicLong countValueAtmoic=new AtomicLong(0);

    93. protected int[] preInit;

    94. protected int index;

    95. protected AtomicInteger indexAtomic=new AtomicInteger(0);

    96. Random r=new Random(47);

    97. //任务栅栏，同批任务，先到达wait的任务挂起，一直等到全部任务到达制定的wait地点后，才能全部唤醒，继续执行

    98. private CyclicBarrier cb;

    99. public TestTemplate(String _id,int _round,int _threadNum,CyclicBarrier _cb){

    100. this.id=_id;

    101. this.round=_round;

    102. this.threadNum=_threadNum;

    103. cb=_cb;

    104. preInit=new int[round];

    105. for(int i=0;i<preInit.length;i++){

    106. preInit[i]=r.nextInt(100);

    107. }

    108. }

    109. abstract void sumValue();

    110. /*

    111. * 对long的操作是非原子的，原子操作只针对32位

    112. * long是64位，底层操作的时候分2个32位读写，因此不是线程安全

    113. */

    114. abstract long getValue();

    115. public void testTime(){

    116. ExecutorService se=Executors.newCachedThreadPool();

    117. long start=System.nanoTime();

    118. //同时开启2*ThreadNum个数的读写线程

    119. for(int i=0;i<threadNum;i++){

    120. se.execute(new Runnable(){

    121. public void run() {

    122. for(int i=0;i<round;i++){

    123. sumValue();

    124. }

    125. //每个线程执行完同步方法后就等待

    126. try {

    127. cb.await();

    128. } catch (InterruptedException e) {

    129. // TODO Auto-generated catch block

    130. e.printStackTrace();

    131. } catch (BrokenBarrierException e) {

    132. // TODO Auto-generated catch block

    133. e.printStackTrace();

    134. }

    135. }

    136. });

    137. se.execute(new Runnable(){

    138. public void run() {

    139. getValue();

    140. try {

    141. //每个线程执行完同步方法后就等待

    142. cb.await();

    143. } catch (InterruptedException e) {

    144. // TODO Auto-generated catch block

    145. e.printStackTrace();

    146. } catch (BrokenBarrierException e) {

    147. // TODO Auto-generated catch block

    148. e.printStackTrace();

    149. }

    150. }

    151. });

    152. }

    153. try {

    154. //当前统计线程也wait,所以CyclicBarrier的初始值是threadNum*2+1

    155. cb.await();

    156. } catch (InterruptedException e) {

    157. // TODO Auto-generated catch block

    158. e.printStackTrace();

    159. } catch (BrokenBarrierException e) {

    160. // TODO Auto-generated catch block

    161. e.printStackTrace();

    162. }

    163. //所有线程执行完成之后，才会跑到这一步

    164. long duration=System.nanoTime()-start;

    165. out.println(id+" = "+duration);

    166. }

    167. }

Lock与synchronized 的区别,布布扣,bubuko.com

时间： 2024-11-03 21:25:51

Lock与synchronized 的区别的相关文章

lock和synchronized的区别

与synchronized类似的,lock也能够达到同步的效果 Lock是一个接口,为了使用一个Lock对象,需要用到 Lock lock = new ReentrantLock(): lock必须调用unlock方法进行手动释放,为了保证释放的执行,往往会把unlock() 放在finally中进行. synchronized 是不占用到手不罢休的,会一直试图占用下去.与 synchronized 的钻牛角尖不一样,Lock接口还提供了一个trylock方法.trylock会在指定时间范围内试

Java同步锁——lock与synchronized 的区别【转】

一.Lock和synchronized有以下几点不同: 1)Lock是一个接口,而synchronized是Java中的关键字,synchronized是内置的语言实现,synchronized是在JVM层面上实现的,不但可以通过一些监控工具监控synchronized的锁定,而且在代码执行时出现异常,JVM会自动释放锁定,但是使用Lock则不行,lock是通过代码实现的,要保证锁定一定会被释放,就必须将 unLock()放到finally{} 中: 2)synchronized在发生异常时,会

Lock与synchronized的区别

synchronized是属于jvm层面的,如果遇到异常,jvm会自动释放锁.lock锁的释放是需要程序员操作,如果不释放就会产生死锁 在竞争不激烈的情况下,偶尔会有同步的情况发生,如果用synchronized会好一点,如果竞争很激烈的情况下,使用reentrantLock会好一点. package org.fkjava.oa.base; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.Reen

多线程之：lock和synchronized的区别

多次思考过这个问题,都没有形成理论,今天有时间了,我把他总结出来,希望对大家有所帮助 1.ReentrantLock 拥有Synchronized相同的并发性和内存语义,此外还多了 锁投票,定时锁等候和中断锁等候 线程A和B都要获取对象O的锁定,假设A获取了对象O锁,B将等待A释放对O的锁定, 如果使用 synchronized ,如果A不释放,B将一直等下去,不能被中断 如果 使用ReentrantLock,如果A不释放,可以使B在等待了足够长的时间以后,中断等待,而干别的事情 Reentra

lock 和synchronized 的区别

1  lock是接口实现,synchronized是内置方法native实现 2 lock可以主动释放锁,synchronized只能是加锁的代码块执行完毕或者遇到异常退出被动的释放锁 3 性能方面,如果竞争资源不是很激烈的情况,两者的性能差不太多,如果是在竞争资源激烈的情况下,lock的性能要优于synchronized,但是这个也不是绝对的, 在JDK6 以后对synchronized做了进一步的优化和提升,synchronized的性能也获得了很大的提升和改进,在一定程度上和lock没有太

lock与synchronized区别详解

1.线程与进程: 在开始之前先把进程与线程进行区分一下,一个程序最少需要一个进程,而一个进程最少需要一个线程. 线程是程序执行流的最小单位,而进程是系统进行资源分配和调度的一个独立单位. 2.Thread的几个重要方法: 我们先了解一下Thread的几个重要方法. a.start()方法,开始执行该线程:b.stop()方法,强制结束该线程执行:c.join方法,等待该线程结束.d.sleep()方法,线程进入等待.e.run()方法,直接执行线程的run()方法,但是线程调用start()方法

synchronized与static synchronized 的区别、synchronized在JVM底层的实现原理及Java多线程锁理解

本Blog分为如下部分: 第一部分:synchronized与static synchronized 的区别 第二部分:JVM底层又是如何实现synchronized的 第三部分:Java多线程锁,源代码剖析 第一部分:synchronized与static synchronized的区别 1.synchronized与static synchronized 的区别 synchronized是对类的当前实例进行加锁,防止其他线程同时访问该类的该实例的所有synchronized块,注意这里是"类

ReentrantLock详解 以及与synchronized的区别

ReentrantLock lock = new ReentrantLock(); //参数默认false,不公平锁 ReentrantLock lock = new ReentrantLock(true); //公平锁 lock.lock(); //如果被其它资源锁定,会在此等待锁释放,达到暂停的效果 try { //操作 } finally { lock.unlock(); } Java 理论与实践: JDK 5.0 中更灵活.更具可伸缩性的锁定机制 新的锁定类提高了同步性 -- 但还不能现

synchronized与static synchronized 的区别

1.synchronized与static synchronized 的区别 synchronized是对类的当前实例进行加锁,防止其他线程同时访问该类的该实例的所有synchronized块,注意这里是"类的当前实例", 类的两个不同实例就没有这种约束了.那么static synchronized恰好就是要控制类的所有实例的访问了,static synchronized是限制线程同时访问jvm中该类的所有实例同时访问对应的代码快.实际上,在类中某方法或某代码块中有 synchroni