`
asme2u
  • 浏览: 4499 次
  • 性别: Icon_minigender_1
  • 来自: 北京
最近访客 更多访客>>
文章分类
社区版块
存档分类
最新评论

最简单高效的tryLock

多线程XPCentOS软件测试应用服务器 
阅读更多 
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * @author asme2u
 */
public class Lock {

    private AtomicBoolean lock = new AtomicBoolean(true);

    public boolean tryLock() {
        return lock.compareAndSet(true, false);
    }

    public void unlock() {
        lock.set(true);
    }

}

 

原理：CAS

 

优点：

     速度快，约是ReentrantLock的2-3倍

 

 缺点：

     需JDK5.0+

     无条件对象且不可重入

     未获取锁时直接调用unlock不抛IllegalMonitorStateException所以代码必须严格保证获取锁后才能调用unlock

 

适用场景：

    不需要条件对象且当ReentrantLock的tryLock影响了你的性能的时候

 

我的应用场景：

    最近项目中通信程序中的客户端的socket长连接的连接池，客户端使用连接具有高并发但占用连接时间非常短的特点，使用这个类代替ReentrantLock，性能提高了3倍左右

分享到：
评论
43 楼 daly1987 2011-12-14  
确实不错，项目上也在用，用AtomicInteger也可以的
42 楼 beneo 2010-09-25  
asme2u 写道
mercyblitz 写道
asme2u 写道
有判断语句，不光只有一条修改语句
大致是这样的意思：
if(l.tryLock()) {
  if(!busyFlag) {
    busyFlag = true;
  }

  l.unlock();
}

那个标志是个volatile

  看来你领悟的奥义了。

呵呵，谈不上领悟，到是确实没注意到也没用到b1=!b2这样的情况，所以没明白为什么你说volatile也还存在问题


volatile 只能保证可见，不能保证原子

你在try finally块保证了原子

我猜他是这个意思
41 楼 asme2u 2010-09-25  
mercyblitz 写道
asme2u 写道
有判断语句，不光只有一条修改语句
大致是这样的意思：
if(l.tryLock()) {
  if(!busyFlag) {
    busyFlag = true;
  }

  l.unlock();
}

那个标志是个volatile

  看来你领悟的奥义了。

呵呵，谈不上领悟，到是确实没注意到也没用到b1=!b2这样的情况，所以没明白为什么你说volatile也还存在问题
40 楼 mercyblitz 2010-09-25  
asme2u 写道
有判断语句，不光只有一条修改语句
大致是这样的意思：
if(l.tryLock()) {
  if(!busyFlag) {
    busyFlag = true;
  }

  l.unlock();
}

那个标志是个volatile

  看来你领悟的奥义了。
39 楼 asme2u 2010-09-25  
有判断语句，不光只有一条修改语句
大致是这样的意思：
if(l.tryLock()) {
  if(!busyFlag) {
    busyFlag = true;
  }

  l.unlock();
}

那个标志是个volatile
38 楼 mercyblitz 2010-09-25  
asme2u 写道
mercyblitz 写道
asme2u 写道
mercyblitz 写道
asme2u 写道
的确，中间的那段，我们开发的时候意识到了，使用的是一个volatile变量作为标志繁忙状态而已，可能在别的场合下，中间的那段会发生CPU缓存中的变量与内存中的不一致的情况


恩，volatile 还是不行，还是因为原子操作的问题。

volatile不支持并发修改，但是能保证修改被立刻看到，又为何不行？
不过以前在那里看到说JDK5.0前volatile实现得不好，没太关注，早不用老版本了



volatile 支持并发修改，并且保证了JSL规范中定义的Happens-before关系。

但是由于它是偏续关系，所以不满足“因果一致性”

比如：

volatile boolean b1;
volatile boolean b2;

如果b2依赖于b1,比如 
｛
   //b1可能是true或者false;
   b2 = !b1; //如果是volatile的关系，b2不确定。但是如果b1,b2在同步中，那么b1和b2的值都被锁定了。
    
｝


谢谢，你这么一说我明白了，如果只是对一个volatile操作就如我所说的，仅仅一个标志而已，就没问题了吧


对的，如果只有一个变量的话，也没有必要任何辅助代。



37 楼 asme2u 2010-09-25  
mercyblitz 写道
asme2u 写道
mercyblitz 写道
asme2u 写道
的确，中间的那段，我们开发的时候意识到了，使用的是一个volatile变量作为标志繁忙状态而已，可能在别的场合下，中间的那段会发生CPU缓存中的变量与内存中的不一致的情况


恩，volatile 还是不行，还是因为原子操作的问题。

volatile不支持并发修改，但是能保证修改被立刻看到，又为何不行？
不过以前在那里看到说JDK5.0前volatile实现得不好，没太关注，早不用老版本了



volatile 支持并发修改，并且保证了JSL规范中定义的Happens-before关系。

但是由于它是偏续关系，所以不满足“因果一致性”

比如：

volatile boolean b1;
volatile boolean b2;

如果b2依赖于b1,比如 
｛
   //b1可能是true或者false;
   b2 = !b1; //如果是volatile的关系，b2不确定。但是如果b1,b2在同步中，那么b1和b2的值都被锁定了。
    
｝


谢谢，你这么一说我明白了，如果只是对一个volatile操作就如我所说的，仅仅一个标志而已，就没问题了吧
36 楼 mercyblitz 2010-09-25  
asme2u 写道
mercyblitz 写道
asme2u 写道
的确，中间的那段，我们开发的时候意识到了，使用的是一个volatile变量作为标志繁忙状态而已，可能在别的场合下，中间的那段会发生CPU缓存中的变量与内存中的不一致的情况


恩，volatile 还是不行，还是因为原子操作的问题。

volatile不支持并发修改，但是能保证修改被立刻看到，又为何不行？
不过以前在那里看到说JDK5.0前volatile实现得不好，没太关注，早不用老版本了



volatile 支持并发修改，并且保证了JSL规范中定义的Happens-before关系。

但是由于它是偏续关系，所以不满足“因果一致性”

比如：

volatile boolean b1;
volatile boolean b2;

如果b2依赖于b1,比如 
｛
   //b1可能是true或者false;
   b2 = !b1; //如果是volatile的关系，b2不确定。但是如果b1,b2在同步中，那么b1和b2的值都被锁定了。
    
｝

35 楼 asme2u 2010-09-25  
mxswl 写道
软件包 java.util.concurrent.atomic 的描述:

类的小工具包，支持在单个变量上解除锁定的线程安全编程。事实上，此包中的类可将 volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。

楼主的这个锁和自旋锁还是有区别的，因为用户有机会定制"就算拿不到锁，我要做的事情"

public void lock() {
for (;;) {
if (lock.compareAndSet(true, false)) {
break;
}
try {
Thread.sleep(0, 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}


模拟自旋锁，可否？
34 楼 mxswl 2010-09-25  
软件包 java.util.concurrent.atomic 的描述:

类的小工具包，支持在单个变量上解除锁定的线程安全编程。事实上，此包中的类可将 volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。

楼主的这个锁和自旋锁还是有区别的，因为用户有机会定制"就算拿不到锁，我要做的事情"
33 楼 asme2u 2010-09-25  
mercyblitz 写道
asme2u 写道
的确，中间的那段，我们开发的时候意识到了，使用的是一个volatile变量作为标志繁忙状态而已，可能在别的场合下，中间的那段会发生CPU缓存中的变量与内存中的不一致的情况


恩，volatile 还是不行，还是因为原子操作的问题。

volatile不支持并发修改，但是能保证修改被立刻看到，又为何不行？
不过以前在那里看到说JDK5.0前volatile实现得不好，没太关注，早不用老版本了
32 楼 mercyblitz 2010-09-25  
asme2u 写道
的确，中间的那段，我们开发的时候意识到了，使用的是一个volatile变量作为标志繁忙状态而已，可能在别的场合下，中间的那段会发生CPU缓存中的变量与内存中的不一致的情况


恩，volatile 还是不行，还是因为原子操作的问题。
31 楼 asme2u 2010-09-25  
的确，中间的那段，我们开发的时候意识到了，使用的是一个volatile变量作为标志繁忙状态而已，可能在别的场合下，中间的那段会发生CPU缓存中的变量与内存中的不一致的情况
30 楼 mercyblitz 2010-09-25  
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<div class="quote_title">mercyblitz 写道</div>
<div class="quote_div">
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<div class="quote_title">
<pre name="code" class="java">if(l.tryLock()) {
  try{

   // 这里能有多个线程同时到达？

  } finally {
    l.unlock
  }

}</pre>
 mercyblitz 写道</div>
<div class="quote_div">
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<div class="quote_title">mercyblitz 写道</div>
<div class="quote_div">
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<div class="quote_title">hellojinjie 写道</div>
<div class="quote_div">
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<br><div class="quote_title">ellojinjie 写道</div>
<div class="quote_div">性能应该只与线程执有锁的时间和多少个线程竞争该锁有关，，为什么会和线程如何得到锁有关？？？ <br><br>你用tryLock，应该是自旋锁这一类的吧，在我的单核的CPU上，恐怕也不会有什么性能的提高。。。</div>
<br>我实际应用场景是高并发，短占用，如果你应用场景从获取锁到释放锁需要很长的时间，性能不会有多少提高 <br><br><br>
</div>
<br>看来是ReentrantLock 里的tryLock太耗时了，才会使得用AtomicBoolean实现的Lock性能比ReentryLock好</div>
<br>正解，只有符合锁占用的时间与获取锁的时间可比拟时，这个类才有意义，所以我列出了适用场景。 <br>
</div>
<br><br>你要看情况， <br>建议楼主看一下为什么要引入偏向锁，就是为了解决CAS延迟问题。<a href="http://blogs.sun.com/dave/entry/biased_locking_in_hotspot" target="_blank">http://blogs.sun.com/dave/entry/biased_locking_in_hotspot</a> <br><br>你所说的场景不过是你-client的设置罢了，多核CPU再来试试。</div>
<br>看了一下你的链接，谢谢你的提醒，确实有延迟的问题，如果这么考虑，是否CAS都不可靠了呢？这些个原子类什么时候适用？</div>
<br><br><br>在你的代码中，那个逻辑判断是可靠的，但是中间的执行代码是线程不安全的。 <br><br>PS:CAS是可靠的，它是Wait-free的实现，不过它只能针对单个资源安全，不能作为多语句的原子操作。</div>
<p> </p>
<p> </p>
</div>
<p> </p>
<p>是的，代码中没有让线程等待。</p>
<p> </p>
</div>
<p>CAS是个原子操作，不可能被打断，那怎么可能会有两个线程执行 lock.compareAndSet(true, false)这个都返回true呢？</p>
</div>
<p> </p>
<p>恩，你是对的，不过中间代码端的资源没有同步主存。</p>
29 楼 asme2u 2010-09-25  
代码中没有让线程等待是因为这是个tryLock，我的应用中是用它来控制线程争用连接池中的连接，每个连接上都有这样一个Lock，如果tryLock成功且连接空闲状态，则修改一下状态位后立刻unlock，如果连接繁忙则直接unlock，如果tryLock不成功，则去尝试下一个连接
28 楼 asme2u 2010-09-25  
<div class="quote_title">mercyblitz 写道</div>
<div class="quote_div">
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<div class="quote_title">
<pre name="code" class="java">if(l.tryLock()) {
  try{

   // 这里能有多个线程同时到达？

  } finally {
    l.unlock
  }

}</pre>
 mercyblitz 写道</div>
<div class="quote_div">
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<div class="quote_title">mercyblitz 写道</div>
<div class="quote_div">
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<div class="quote_title">hellojinjie 写道</div>
<div class="quote_div">
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<br><div class="quote_title">ellojinjie 写道</div>
<div class="quote_div">性能应该只与线程执有锁的时间和多少个线程竞争该锁有关，，为什么会和线程如何得到锁有关？？？ <br><br>你用tryLock，应该是自旋锁这一类的吧，在我的单核的CPU上，恐怕也不会有什么性能的提高。。。</div>
<br>我实际应用场景是高并发，短占用，如果你应用场景从获取锁到释放锁需要很长的时间，性能不会有多少提高 <br><br><br>
</div>
<br>看来是ReentrantLock 里的tryLock太耗时了，才会使得用AtomicBoolean实现的Lock性能比ReentryLock好</div>
<br>正解，只有符合锁占用的时间与获取锁的时间可比拟时，这个类才有意义，所以我列出了适用场景。 <br>
</div>
<br><br>你要看情况， <br>建议楼主看一下为什么要引入偏向锁，就是为了解决CAS延迟问题。<a href="http://blogs.sun.com/dave/entry/biased_locking_in_hotspot" target="_blank">http://blogs.sun.com/dave/entry/biased_locking_in_hotspot</a> <br><br>你所说的场景不过是你-client的设置罢了，多核CPU再来试试。</div>
<br>看了一下你的链接，谢谢你的提醒，确实有延迟的问题，如果这么考虑，是否CAS都不可靠了呢？这些个原子类什么时候适用？</div>
<br><br><br>在你的代码中，那个逻辑判断是可靠的，但是中间的执行代码是线程不安全的。 <br><br>PS:CAS是可靠的，它是Wait-free的实现，不过它只能针对单个资源安全，不能作为多语句的原子操作。</div>
<p> </p>
<p> </p>
</div>
<p> </p>
<p>是的，代码中没有让线程等待。</p>
<p> </p>
</div>
<p>CAS是个原子操作，不可能被打断，那怎么可能会有两个线程执行 lock.compareAndSet(true, false)这个都返回true呢？</p>
27 楼 wkoffee 2010-09-25  
mercyblitz 写道
wkoffee 写道
我自己测下来用synchronized关键字更快，我想应该是这种spin lock有很多cas操作都是无效的，cas本身也是代价很大的。



JDK 1.6 默认的开启了-XX:+UseBiasedLocking , 使用了偏向锁，自旋锁是1.6之前默认的，自旋锁的性能也不好。


并不是偏向锁的功劳，这个例子高度竞争，明显不是偏向锁擅长的类型，使用偏向锁反而会降低性能，我用了-XX:-UseBiasedLocking后速度又提高了。
26 楼 mxswl 2010-09-25  
<div class="quote_title">mercyblitz 写道</div>
<div class="quote_div">
<p> </p>
<p> </p>
<p>我的天啊， 在同步（互斥）中间执行的代码叫做“临界区”，AtomicX类都是Nonblocking的，怎么取保其他线程不进入“临界区”，这个不算的话。线程安全，还应该保证 Thread的读和写的数据和主存中的一致。你这个类怎么取保？</p>
</div>
<p> </p>
<p>正如其函数名，叫try lock，而不是lock,可以在避免当前线程直接陷入阻塞的情况下去获得锁，如果当前线程有类似很多高用户交互的行为，这种锁很重要。</p>
<p> </p>
<p>临界区的保证是需要应用层和框架共同提供的，这不过就是一个锁。</p>
25 楼 mercyblitz 2010-09-25  
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<div class="quote_title">
<pre name="code" class="java">if(l.tryLock()) {
  try{

   // 这里能有多个线程同时到达？

  } finally {
    l.unlock
  }

}</pre>
 mercyblitz 写道</div>
<div class="quote_div">
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<div class="quote_title">mercyblitz 写道</div>
<div class="quote_div">
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<div class="quote_title">hellojinjie 写道</div>
<div class="quote_div">
<div class="quote_title">asme2u 写道</div>
<div class="quote_div">
<br><div class="quote_title">ellojinjie 写道</div>
<div class="quote_div">性能应该只与线程执有锁的时间和多少个线程竞争该锁有关，，为什么会和线程如何得到锁有关？？？ <br><br>你用tryLock，应该是自旋锁这一类的吧，在我的单核的CPU上，恐怕也不会有什么性能的提高。。。</div>
<br>我实际应用场景是高并发，短占用，如果你应用场景从获取锁到释放锁需要很长的时间，性能不会有多少提高 <br><br><br>
</div>
<br>看来是ReentrantLock 里的tryLock太耗时了，才会使得用AtomicBoolean实现的Lock性能比ReentryLock好</div>
<br>正解，只有符合锁占用的时间与获取锁的时间可比拟时，这个类才有意义，所以我列出了适用场景。 <br>
</div>
<br><br>你要看情况， <br>建议楼主看一下为什么要引入偏向锁，就是为了解决CAS延迟问题。<a href="http://blogs.sun.com/dave/entry/biased_locking_in_hotspot" target="_blank">http://blogs.sun.com/dave/entry/biased_locking_in_hotspot</a> <br><br>你所说的场景不过是你-client的设置罢了，多核CPU再来试试。</div>
<br>看了一下你的链接，谢谢你的提醒，确实有延迟的问题，如果这么考虑，是否CAS都不可靠了呢？这些个原子类什么时候适用？</div>
<br><br><br>在你的代码中，那个逻辑判断是可靠的，但是中间的执行代码是线程不安全的。 <br><br>PS:CAS是可靠的，它是Wait-free的实现，不过它只能针对单个资源安全，不能作为多语句的原子操作。</div>
<p> </p>
<p> </p>
</div>
<p> </p>
<p>是的，代码中没有让线程等待。</p>
24 楼 mercyblitz 2010-09-25  
wkoffee 写道
我自己测下来用synchronized关键字更快，我想应该是这种spin lock有很多cas操作都是无效的，cas本身也是代价很大的。



JDK 1.6 默认的开启了-XX:+UseBiasedLocking , 使用了偏向锁，自旋锁是1.6之前默认的，自旋锁的性能也不好。
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java的lock和synchronized的区别.docx

    tryLock() 仅在调用时锁为空闲状态才获取该锁。如果锁可用，则获取锁，并立即返回值 true。如果锁不可用，则此方法将立即返回值 false。 lock 和 synchronized 都是锁的意思，但是它们有不同的实现机制和应用场景。...

    分布式锁与信号量教程.docx

    public static boolean tryLock(String lockKey, int expireSeconds) { Jedis jedis = new Jedis("localhost", 6379); String result = jedis.set(lockKey, "locked", "NX", "EX", expireSeconds); jedis.close...

    JDK 5.0 中更灵活、更具可伸缩性的锁定机制1

    2. **定时等待**：通过`tryLock(long timeout, TimeUnit unit)`方法，线程可以设定一个等待时间去尝试获取锁，如果超时仍未获取到，线程将返回而不是继续等待。 3. **锁投票**：`ReentrantLock`的`tryLock()`方法...

    Java concurrency之互斥锁_动力节点Java学院整理

    这与`synchronized`块类似，但`ReentrantLock`提供了更细粒度的控制，如尝试非阻塞获取锁(`tryLock()`)、可中断的锁获取(`lockInterruptibly()`)以及对锁状态的查询方法。 总结来说，`ReentrantLock`是Java并发编程...

    java多线程死锁预防机制研究

    if (lock.tryLock(1000, TimeUnit.MILLISECONDS)) { // 尝试获取锁，超时时间为1秒 try { // 执行关键代码段 } finally { lock.unlock(); // 释放锁 } } else { System.out.println("Lock acquisition timed...

    java简单程序小例子

    Java是一种广泛使用的面向对象的编程语言，以其跨平台性、高效性和安全性著称。"Java简单程序小例子"是学习Java编程的初级阶段常见的实践项目，通常包含一系列基础的代码示例，帮助初学者理解语言的基本语法和常用...

    Linux内核同步操作详解

    例如，`down_trylock()`和`up_read_trylock()`这样的宏可以帮助开发者在某些情况下避免等待锁。 #### 八、结语 《Linux内核同步操作详解》为开发者提供了丰富的理论知识和技术细节，帮助他们在开发驱动程序或其他...

    java并发编程学习思维导图

    - **Lock锁**：ReentrantLock是可重入锁，提供了比synchronized更细粒度的控制，如tryLock()、unlock()等。 3. **并发工具类** - **CountDownLatch**：用于计数，常用于多线程协同工作，当计数器归零时，所有等待...

    C#版本简单线程调用源码

    其中，`lock`是最常用的一种，用于控制对共享资源的访问。 4. **线程池** 线程池是一种线程复用机制，它可以避免频繁创建和销毁线程的开销。C#的线程池由`ThreadPool`类提供。你可以通过`ThreadPool....

    ThreadLocked多线程共享资源

    `lock`是C#中实现互斥访问的最简单方式。它基于`Monitor`类，确保同一时刻只有一个线程可以执行锁定的代码块： ```csharp object obj = new object(); lock (obj) { // 共享资源的代码 } ``` 这里，`obj`作为锁...

    【BAT必备】并发编程锁面试题

    - **synchronized关键字**：这是最简单的锁实现方式，可以应用于方法或者代码块。 - **ReentrantLock类**：这是一个可重入的互斥锁，比synchronized更灵活，提供了一系列高级功能。 - **ReentrantReadWriteLock类**...

    关于Linux多线程编程.pdf

    pthread_mutex_trylock用于尝试加锁，而不会阻塞。 2. 条件变量：条件变量是与互斥锁联合使用的同步机制，用于线程间的协调。条件变量允许线程因为某个条件未满足而处于阻塞状态，直到其他线程改变了这个条件并发送...

    一个简单的线程同步实例

    首先，我们来看最基本的同步机制——synchronized关键字。synchronized可以用于方法或者代码块，当它包裹的代码被执行时，会创建一个监视器锁，只有一个线程能获取这个锁并执行代码，其他线程必须等待锁的释放。例如...

    自定义消息的简单实现(c++)

    这个简单的实现展示了如何在C++中创建自定义消息系统，包括定义消息结构、存储消息、发送和接收消息以及处理消息的逻辑。通过这种方式，你可以根据项目需求定制自己的通信协议，以实现更高效、更灵活的程序设计。...

    多线程面试专题及答案.pdf

    - **解答**: 要实现线程之间的执行顺序，最简单的方法是使用`join()`方法。例如： ```java Thread t1 = new Thread(() -&gt; { // T1 的任务 }); Thread t2 = new Thread(() -&gt; { // T2 的任务 }); Thread t3 =...

    【并发编程】简单化理解AQS和ReentrantLock.pdf

    - 可以通过tryLock尝试获取锁，增加灵活性。 - 提供更精细的锁释放控制，避免异常导致的死锁。 #### 5. 认识AQS - **AQS内部实现**： - 通过`state`字段记录锁的状态，使用CAS操作进行原子更新。 - 通过FIFO...

    java多线程实现生产者和消费者

    通常，使用阻塞队列是最简单且高效的解决方案，因为它已经内置了同步和等待机制。然而，在某些特定情况下，如需要更灵活的同步控制或者更高的性能，其他方法可能更合适。理解并熟练掌握这些机制对于进行高并发的Java...

    C# 线程thread 教程

    - `lock`是C#中最简单的同步原语，它基于Monitor对象实现： ```csharp lock (obj) { // 访问共享资源的代码 } ``` 5. **线程池** - .NET框架中的线程池（ThreadPool）是一种高效的线程管理机制，它可以重用...

    Java多线程 简单例子

    除了基本的线程创建和控制，Java还提供了丰富的同步机制，如`synchronized`关键字、`wait()`, `notify()`, `notifyAll()`方法，以及`Lock`接口（如`ReentrantLock`）和`Condition`接口，以支持更复杂的并发控制。...

Magicbox
Global site tag (gtag.js) - Google Analytics