lock ,tryLock lockInterruptibly 区别



ReentrantLock 锁有好几种,除了常用的lock ,tryLock ,其中有个lockInterruptibly 。
先把API粘贴上来
lock
public void lock()
获取锁。
如果该锁没有被另一个线程保持,则获取该锁并立即返回,将锁的保持计数设置为 1。
如果当前线程已经保持该锁,则将保持计数加 1,并且该方法立即返回。
如果该锁被另一个线程保持,则出于线程调度的目的,禁用当前线程,并且在获得锁之前,该线程将一
直处于休眠状态,此时锁保持计数被设置为 1。

指定者:
接口 Lock 中的 lock


lockInterruptibly
public void lockInterruptibly() throws InterruptedException
1)如果当前线程未被中断,则获取锁。 

2)如果该锁没有被另一个线程保持,则获取该锁并立即返回,将锁的保持计数设置为 1。 

3)如果当前线程已经保持此锁,则将保持计数加 1,并且该方法立即返回。 

4)如果锁被另一个线程保持,则出于线程调度目的,禁用当前线程,并且在发生以下两种情况之一以
前,该线程将一直处于休眠状态: 
     1)锁由当前线程获得;或者 

     2)其他某个线程中断当前线程。 

5)如果当前线程获得该锁,则将锁保持计数设置为 1。 
   如果当前线程: 
       1)在进入此方法时已经设置了该线程的中断状态;或者 

       2)在等待获取锁的同时被中断。 

   则抛出 InterruptedException,并且清除当前线程的已中断状态。 


6)在此实现中,因为此方法是一个显式中断点,所以要优先考虑响应中断,而不是响应锁的普通获取或
重入获取。 

指定者: 接口 Lock 中的 lockInterruptibly
抛出:   InterruptedException   如果当前线程已中断。


tryLock    public boolean tryLock()

仅在调用时锁未被另一个线程保持的情况下,才获取该锁。 

1)如果该锁没有被另一个线程保持,并且立即返回 true 值,则将锁的保持计数设置为 1。
即使已将此锁设置为使用公平排序策略,但是调用 tryLock() 仍将 立即获取锁(如果有可用的),
而不管其他线程当前是否正在等待该锁。在某些情况下,此“闯入”行为可能很有用,即使它会打破公
平性也如此。如果希望遵守此锁的公平设置,则使用 tryLock(0, TimeUnit.SECONDS) 
,它几乎是等效的(也检测中断)。 

2)如果当前线程已经保持此锁,则将保持计数加 1,该方法将返回 true。 

3)如果锁被另一个线程保持,则此方法将立即返回 false 值。 

指定者:
   接口 Lock 中的  tryLock
返回: 
   如果锁是自由的并且被当前线程获取,或者当前线程已经保持该锁,则返回 true;否则返回 
false


关于中断又是一段很长的叙述,先不谈。

1)lock(), 拿不到lock就不罢休,不然线程就一直block。 比较无赖的做法。
2)tryLock(),马上返回,拿到lock就返回true,不然返回false。 比较潇洒的做法。
带时间限制的tryLock(),拿不到lock,就等一段时间,超时返回false。比较聪明的做法。

3)lockInterruptibly()就稍微难理解一些。


先说说线程的打扰机制,每个线程都有一个 打扰 标志。这里分两种情况,
1. 线程在sleep或wait,join, 此时如果别的进程调用此进程的 interrupt()方法,此线程会被唤醒并被要求处理InterruptedException;(thread在做IO操作时也可能有类似行为,见java thread api)


2. 此线程在运行中, 则不会收到提醒。但是 此线程的 “打扰标志”会被设置, 可以通过isInterrupted()查看并 作出处理。


lockInterruptibly()和上面的第一种情况是一样的, 线程在请求lock并被阻塞时,如果被interrupt,则“此线程会被唤醒并被要求处理InterruptedException”。并且如果线程已经被interrupt,再使用lockInterruptibly的时候,此线程也会被要求处理interruptedException




先看lock()方法
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 作者 E-mail:
 * @version 创建时间:2015-10-23 下午01:47:03 类说明
 */
public class TestLock
{
    // @Test
    public void test() throws Exception
    {
        final Lock lock = new ReentrantLock();
        lock.lock();

        
        Thread t1 = new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + " interrupted.");
            }
        },"child thread -1");
        
        t1.start();
        Thread.sleep(1000);
        
        t1.interrupt();
        
        Thread.sleep(1000000);
    }
    
    public static void main(String[] args) throws Exception
    {
        new TestLock().test();
    }
}

用eclipse对这个程序进行debug发现,即使子线程已经被打断,但是子线程仍然在run,可见lock()方法并不关心线程是否被打断,甚至说主线程已经运行完毕,子线程仍然在block().

<img src="https://i-blog.csdnimg.cn/blog_migrate/2a64ff2fb027a1dd9b9bd823d7bdc6e0.png" data-rawwidth="485" data-rawheight="117" class="origin_image zh-lightbox-thumb" width="485" data-original="https://pic3.zhimg.com/d32ce02804a5dd69ed17b515b8f400ae_r.png">
而使用LockInterupptibly,则会响应中断
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 作者 E-mail:
 * @version 创建时间:2015-10-23 下午01:53:10 类说明
 */
public class TestLockInterruptibly
{

    // @Test
    public void test3() throws Exception
    {
        final Lock lock = new ReentrantLock();
        lock.lock();

        Thread t1 = new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                try
                {
                    lock.lockInterruptibly();
                }
                catch(InterruptedException e)
                {
                    System.out.println(Thread.currentThread().getName() + " interrupted.");
                }
            }
        }, "child thread -1");

        t1.start();
        Thread.sleep(1000);

        t1.interrupt();

        Thread.sleep(1000000);
    }

    public static void main(String[] args) throws Exception
    {
        new TestLockInterruptibly().test3();
    }
}

<img src="https://i-blog.csdnimg.cn/blog_migrate/66dfc74709bc5524307fbe9f0cf63f38.png" data-rawwidth="488" data-rawheight="125" class="origin_image zh-lightbox-thumb" width="488" data-original="https://pic4.zhimg.com/b6cd365d05e9d7afd89f3d052b47f757_r.png"> <img src="https://i-blog.csdnimg.cn/blog_migrate/d16df735bf8bacf0d61f2b59eafd50db.png" data-rawwidth="704" data-rawheight="90" class="origin_image zh-lightbox-thumb" width="704" data-original="https://pic1.zhimg.com/9bbbc7ec0244b0ca82e9d24cf10804f0_r.png">
try{
      Thread.sleep(2000);
      lock.lockInterruptibly();
   }catch(InterruptedException e){
       System.out.println(Thread.currentThread().getName()+" interrupted.");
}
  t1.start();
  t1.interrupt();
  Thread.sleep(1000000);

如果将代码改成这样,那么将会在在阻塞之前已经中断,此时再lockInterruptibly()也是会相应中断异常的
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值