java lock锁的使用_lock java

java lock锁的使用_lock java作者:郭无心链接:https://www.zhihu.com/question/36771163/answer/68974735来源:知乎著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。ReentrantLock锁包括:lock,tryLock,其中有个lockInterruptibly publicvoidlock()获取锁。如果该锁没有被另一个线...

作者:郭无心
链接:https://www.zhihu.com/question/36771163/answer/68974735
来源:知乎
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
ReentrantLock 锁包括:lock ,tryLock ,其中有个lockInterruptibly 

public void lock()
获取锁。
如果该锁没有被另一个线程保持,则获取该锁并立即返回,将锁的保持计数设置为 1。
如果当前线程已经保持该锁,则将保持计数加 1,并且该方法立即返回。
如果该锁被另一个线程保持,则出于线程调度的目的,禁用当前线程,并且在获得锁之前,该线程将一
直处于休眠状态,此时锁保持计数被设置为 1。

指定者:
接口 Lock 中的 lock
只听到从架构师办公室传来架构君的声音:
湘娥竹上泪痕浓。有谁来对上联或下联?

 

此代码由Java架构师必看网-架构君整理
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()方法

此代码由Java架构师必看网-架构君整理
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().
 

java lock锁的使用_lock java

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

 

java lock锁的使用_lock java

java lock锁的使用_lock java

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://javajgs.com/archives/165986
0

发表评论