Java中Lock，tryLock，lockInterruptibly有什么区别？

ReentrantLock 锁有好几种，除了常用的lock ，tryLock ，其中有个lockInterruptibly 。
先把API粘贴上来

lock
public void lock()
获取锁。
如果该锁没有被另一个线程保持，则获取该锁并立即返回，将锁的保持计数设置为 1。
如果当前线程已经保持该锁，则将保持计数加 1，并且该方法立即返回。
如果该锁被另一个线程持有，则该线程不可被调度（disabled for thread scheduling purposes）（即阻塞状态，CPU不会给该线程分配时间片）直到该线程获取到该锁，并且在获取到锁后，将保持计数设置为1

指定者：
接口 Lock 中的 lock

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

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

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

如果该锁被另一个线程持有，则该线程不可被调度（disabled for thread scheduling purposes）（即阻塞状态，CPU不会给该线程分配时间片）直到该线程获取到该锁，并且在获取到锁后，将保持计数设置为1

-----> getHoldCount

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().

而使用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();
    }
}

try{
      Thread.sleep(2000);
      lock.lockInterruptibly();
   }catch(InterruptedException e){
       System.out.println(Thread.currentThread().getName()+" interrupted.");
}

  t1.start();
  t1.interrupt();
  Thread.sleep(1000000);

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

转自：https://www.zhihu.com/question/36771163

Java中Lock，tryLock，lockInterruptibly有什么区别？

猜你喜欢