Lock接口获取锁的方法lock，tryLock，lockInterruptibly

最新推荐文章于 2025-04-07 01:19:53 发布
最新推荐文章于 2025-04-07 01:19:53 发布
阅读量331 收藏
点赞数
分类专栏： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yanfei464486/article/details/114876980
版权

lock

package com.yf.reentrantLock;

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

public class DemoLock {

    public static void main(String[] args) {
        int proLen=1;  //一个生产者线程
        int conLen=1;  //一个消费者线程
        Lock lock=new ReentrantLock();
        Thread produtors[]=new Thread[proLen];
        Thread consumers[]=new Thread[conLen];

        for (int i = 0; i < produtors.length; i++) {
            produtors[i]=new Thread(()->{
                sleep(3000); //上来先睡会，让消费者线程先去抢占锁
                lock.lock();  //用来获得锁，如果没有获取到锁，则阻塞状态，等到锁被其他线程释放才能使用
                //因为消费者线程里有个死循环，所以它一直用着这个锁，所以当前线程就没办法获得锁，也一直阻塞状态
                // ，下面的语句就执行不了
                try {
                    System.out.println("生产者线程号："+Thread.currentThread()+"在生产");
                }catch (Exception e){
                    System.out.println("加锁失败，出现异常");
                }finally {
                    lock.unlock();
                }
            });
        }


        int m=9;
        for (int i = 0; i < consumers.length; i++) {
            consumers[i]=new Thread(()->{
                lock.lock();
                System.out.println("消费者线程号"+Thread.currentThread()+"在消费");
                while (true){
                  if(m==5){  //m是9永远不可能到5，所以这个线程会一直运行，而且占用这把锁
                      break;
                  }
                }
                lock.unlock();
            });
        }

        for (Thread produtor : produtors) {
            produtor.start();
        }

        for (Thread consumer : consumers) {
            consumer.start();
        }
    }

    //为了代码简洁，抛异常放入一个方法里面处理
    public static void sleep(long millis){
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

trylock

package com.yf.reentrantLock;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DemoTryLock {

    public static void main(String[] args) {
        int proLen = 1;  //一个生产者线程
        int conLen = 1;  //一个消费者线程
        Lock lock = new ReentrantLock();  //可重入锁
        Thread produtors[] = new Thread[proLen];
        Thread consumers[] = new Thread[conLen];

        for (int i = 0; i < produtors.length; i++) {
            produtors[i] = new Thread(() -> {
                sleep(3000); //上来先睡会，让消费者线程先去抢占锁
                //trylock方法，去尝试获得锁，如果没有获得，则返回false,去执行else后面的方法,不会造成阻塞
                if (lock.tryLock()) {
                    try {
                        System.out.println("生产者线程号：" + Thread.currentThread() + "在生产");
                    } catch (Exception e) {
                        System.out.println("加锁失败，出现异常");
                    } finally {
                        lock.unlock();
                    }
                } else {
                    System.out.println("未获取这把锁，生产者线程停止生产，当前线程也执行完成，非阻塞");
                }

            });
        }


        AtomicInteger m = new AtomicInteger(9);
        for (int i = 0; i < consumers.length; i++) {
            consumers[i] = new Thread(() -> {
                try {
                    lock.lock();
                    System.out.println("消费者线程号" + Thread.currentThread() + "在消费");
                    while (true) {
                        if (m.get() == 2000000000) {  //拉长这个线程的运行时间，让多占用这把锁
                            break;
                        }
                        m.getAndIncrement(); //m自增，这个是原子性的，多线程保证安全
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {

                    lock.unlock();//一般lock.unlock写在final里，保证锁会被释放，防止出现死锁的情况
                }


            });
        }

        for (Thread produtor : produtors) {
            produtor.start();

        }

        for (Thread consumer : consumers) {
            consumer.start();
        }
    }

    //为了代码简洁，抛异常放入一个方法里面处理
    public static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

lockInterruptibly 抢占其他线程的锁

LockTnterruptily 是否能抢夺正在运行其他线程的锁？否

package com.yf.reentrantLock;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//LockTnterruptily 是否能抢夺正在运行其他线程的锁？否
public class DemoLockTnterruptily {

    public static void main(String[] args) {
        int proLen = 1;  //一个生产者线程
        int conLen = 1;  //一个消费者线程
        Lock lock = new ReentrantLock();  //可重入锁
        Thread produtors[] = new Thread[proLen];  //生成者线程
        Thread consumers[] = new Thread[conLen]; //消费者线程

        for (int i = 0; i < produtors.length; i++) {
            produtors[i] = new Thread(() -> {
                sleep(3000); //上来先睡会，让消费者线程先去抢占锁
                //lockInterruptibly，
                    try {
                        //去中断阻塞中的线程（当前消费者线程一段时间
                        // 一直用锁，而且没有阻塞，所以当前线程阻塞了，等到人家用完锁，才能继续往下执行）

                        lock.lockInterruptibly();

                        System.out.println("生产者线程号：" + Thread.currentThread() + "在生产");
                    } catch (Exception e) {
                        System.out.println("加锁失败，出现异常");
                    } finally {
                        lock.unlock();
                    }


            });
        }


        AtomicInteger m = new AtomicInteger(9);
        for (int i = 0; i < consumers.length; i++) {
            consumers[i] = new Thread(() -> {
                try {
                    lock.lock();
                    System.out.println("消费者线程号" + Thread.currentThread() + "在消费");
                    while (true) {
                        if (m.get() == 2000000000) {  //拉长这个线程的运行时间，让多占用这把锁
                            break;
                        }
                        m.getAndIncrement(); //m自增，这个是原子性的，多线程保证安全
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();//一般lock.unlock写在final里，保证锁会被释放，防止出现死锁的情况
                }


            });
        }

        for (Thread produtor : produtors) {
            produtor.start();

        }

        for (Thread consumer : consumers) {
            consumer.start();
        }
    }

    //为了代码简洁，抛异常放入一个方法里面处理
    public static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

LockTnterruptily 是否能抢夺正在阻塞其他线程的锁？是

package com.yf.reentrantLock;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//LockTnterruptily 是否能抢夺正在阻塞其他线程的锁？是
public class DemoLockTnterruptily2 {

    public static void main(String[] args) {
        int proLen = 1;  //一个生产者线程
        int conLen = 1;  //一个消费者线程
        Lock lock = new ReentrantLock();  //可重入锁
        Thread produtors[] = new Thread[proLen];  //生成者线程
        Thread consumers[] = new Thread[conLen]; //消费者线程

        for (int i = 0; i < produtors.length; i++) {
            produtors[i] = new Thread(() -> {
                sleep(3000); //上来先睡会，让消费者线程先去抢占锁
                //lockInterruptibly，
                    try {
                        //去中断阻塞中的线程（当前消费者线程一段时间
                        // 一直用锁，而且没有阻塞，所以当前线程阻塞了，等到人家用完锁，才能继续往下执行）
                        lock.lockInterruptibly();

                        System.out.println("生产者线程号：" + Thread.currentThread() + "在生产");
                    } catch (Exception e) {
                        System.out.println("加锁失败，出现异常");
                    } finally {
                        lock.unlock();
                    }


            });
        }



        for (int i = 0; i < consumers.length; i++) {
            consumers[i] = new Thread(() -> {
                try {
                    lock.lock();
                    System.out.println("消费者线程号" + Thread.currentThread() + "在消费");


                 //   sleep(10000);  使用sleep其他线程也中断不了
                    lock.wait();
                    System.out.println("消费者线程号" + Thread.currentThread() + "消费结束");

                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();//一般lock.unlock写在final里，保证锁会被释放，防止出现死锁的情况
                }


            });
        }

        for (Thread produtor : produtors) {
            produtor.start();

        }

        for (Thread consumer : consumers) {
            consumer.start();
        }
    }

    //为了代码简洁，抛异常放入一个方法里面处理
    public static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
( 五）Lock接口及其实现ReentrantLock
weixin_43770982的博客
05-24 345
jdk1.7.0_79 　　在java.util.concurrent.locks这个包中定义了和synchronized不一样的锁，重入锁——ReentrantLock，读写锁——ReadWriteLock等。在已经有了内置锁synchronized的情况下，为什么又出现了Lock显示锁呢？本文将以Lock作为Java并发包源码解读的开始. 　　Lock定义最基本的加锁和解锁操作。 　　 ...
Lock锁—lock方法源码分析（锁获取）
bc_Reversing的博客
03-17 890
Lock锁是jdk1.5中引入的java线程安全与同步机制。 java.util.concurrent.locks包下常用的类与接口 我们都知道java中锁的出现是为了解决多线程情况下，线程的安全与同步问题，所谓的“线程同步机制”就是一套哦用于协调线程间的数据访问（Data Access）和活动（Activity）的机制，该机制在保证线程安全的同时，实现这些线程的共同目标。 我们都知道在多个线程并发访问共享数据的时候会产生线程安全的问题，如何在多个线程并发的时候保证线程的安全的呢？...
Lock锁及获取锁的四种方法
是小D吖！的博客
11-07 2万+
Lock锁
JavaScript中 Window Location的使用
weixin_46995731的博客
11-19 802
JavaScript中 Window Location的使用 window.location 对象用于获得当前页面的地址 (URL)，并把浏览器重定向到新的页面。 window.location 对象在编写时可不使用 window 这个前缀。 一些例子： 一些实例: location.hostname 返回 web 主机的域名 location.pathname 返回当前页面的路径和文件名 location.port 返回 web 主机的端口 （80 或 443） location.protocol 返回
ReentrantLock中tryLock()和lock()⽅法的区别
最新发布
完全体
04-07 643
tryLock()表示尝试加锁，可能加到，也可能加不到，该⽅法不会阻塞线程，如果加到锁则返回true，没有加到则返回false。lock()表示阻塞加锁，线程会阻塞直到加到锁，⽅法也没有返回值。必须确保锁被获取的场景（如数据库事务、支付扣减）。的语义，但更灵活（可中断、可设置公平性）。：减少线程阻塞时间（如缓存更新、心跳检测）。：非关键任务、死锁预防（如分布式锁）。：如果锁被占用，可以立即回退或重试。如果锁被其他线程持有，当前线程会。：锁被占用时立即返回或超时放弃。：如果锁可用，则获取锁并返回。
Lock 和 tryLock
m0_69529796的博客
03-20 778
LockLock是一种同步机制，用于控制多个线程对共享资源的并发访问。通过锁，只有一个线程能够访问临界区资源，其它线程必须等待锁的释放。Lock是阻塞型锁，适合那些必须获取锁并且线程愿意等待的场景；tryLock是非阻塞型锁，适合那些希望尝试获取锁且能容忍获取失败的场景；Lock必须显式释放锁，而 tryLock可以通过合理的超时机制避免长时间阻塞。tryLock常常用于高并发场景中，提升程序的灵活性和性能，避免资源竞争和死锁问题。
java 中lock,java中lock获取锁的四种方法
weixin_29061997的博客
03-13 475
在java接口中会存放着许多方法，方便线程使用时的直接调用。对于lock接口大家都不陌生，我们已经初步对概念进行了理解。那么在获取锁的方法上想必还不是很清楚。下面我们就lock获取锁的四种方法分别进行概念的介绍，然后就其中的tryLock()方法带来实例代码的展示。1.获取方法lock()、tryLock()、tryLock(long time, TimeUnit unit) 和 lockInte...
java 锁 Lock接口详解.docx
06-21
`Lock`的`tryLock(long time, TimeUnit unit)`方法允许设置等待时间，超时未获得锁则返回。 3. **读写分离**：`synchronized`无法区分读操作和写操作，可能导致读操作的并行性降低。`ReentrantReadWriteLock`提供...
Lock锁的方法使用
ly_jing的博客
07-06 3155
文章目录1 Lock1.1 lock() 方法1.2 tryLock()方法与 tryLock(long time, TimeUnit unit)方法1.3 lockInterruptibly() 方法2 ReentrantLock2.1 lock() 的 正确使用方法2.2 tryLock()的使用方法2.3 lockInterruptibly() 响应中断的使用方法3 ReadWriteLock4 ReentrantReadWriteLock 1 Lock 通过查看 Lock 的源码可知
Lock总结.doc
12-25
4. **尝试获取锁**：`Lock`的`tryLock()`方法可以在无法获取锁时立即返回，而`synchronized`会阻塞直到获得锁。 5. **锁绑定条件**：`Lock`提供了`Condition`接口，可以创建多个条件变量，每个条件对应一个等待队列...
java中lock方法,java中lock获取锁的四种方法
weixin_42651887的博客
03-14 2732
在java接口中会存放着许多方法，方便线程使用时的直接调用。对于lock接口大家都不陌生，我们已经初步对概念进行了理解。那么在获取锁的方法上想必还不是很清楚。下面我们就lock获取锁的四种方法分别进行概念的介绍，然后就其中的tryLock()方法带来实例代码的展示。1.获取方法lock()、tryLock()、tryLock(long time, TimeUnit unit) 和 lockInte...
Lock锁-------tryLock()方法
热门推荐
qq_43323776的博客
10-04 5万+
这一次主要学习Lock接口中的**tryLock()**方法。 tryLock()方法是有返回值的，返回值是Boolean类型。它表示的是用来尝试获取锁：成功获取则返回true；获取失败则返回false，这个方法无论如何都会立即返回。不会像synchronized一样，一个线程获取锁之后，其他锁只能等待那个线程释放之后才能有获取锁的机会。 一般情况下的tryLock获取锁匙这样使用的： //实例化...
Lock的tryLock()方法
松门一枝花
11-21 1万+
概述 tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。 代码 @Test public void testTryLock() { Lock lock = new ReentrantLock(); new Threa
java trylock超时_【java】lock.tryLock()方法的使用
weixin_39591455的博客
02-13 1749
package concurrent;import java.util.ArrayList;import java.util.List;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class TestTryLock {private List list =...
多线程-Lock锁tryLock()
b422761838的专栏
05-09 843
public class TryLockTest { Lock lock = new ReentrantLock(); private ArrayList<Integer> arrayList = new ArrayList<Integer>(); public static void main(String[] args) { final TryLockTest test = new TryLockTest(); new.
Java内置锁：深度解析lock和trylock
科技互联网领域深度探索者，乐于分享与写作。
01-13 2908
lock和tryLock是两种获取锁的方式，它们在处理并发问题时有所不同，lock是阻塞性的，确保只有一个线程能访问被锁资源，但可能导致线程长时间等待；而tryLock非阻塞性，若锁被占用则立即返回失败，避免了长时间等待，但需要更复杂的逻辑处理未能获锁的情况。
多线程环境中lock.trylock方法争抢锁
一只猿的自我修养
01-10 2636
在多线程或分布式环境中，经常需要用到锁，trylock有两种用法，一种是不带参数：不设置等待时间，获取失败立即返回false。另一种是带等待时间的，线程会先挂起等待设置的时间结束如果还未获取到锁则返回false。 下面来看一个多线程争抢锁的实例： public void execWithLock(Lock lock, Supplier<Boolean> supplier) { //Lock lock = new ReentrantLock(); //obtainLock(l
Java Locks框架深度解析：Lock接口与Condition
此外，Lock接口还提供了`tryLock()`方法，尝试获取锁，如果无法立即获取，可以立即返回，而不是阻塞。 二、Condition接口 Condition接口提供了比`wait()`, `notify()`, `notifyAll()`更强大的线程间通信能力。通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值