java 中Lock的使用

最新推荐文章于 2024-03-11 16:53:19 发布
最新推荐文章于 2024-03-11 16:53:19 发布
阅读量1.3w 收藏 14
点赞数 6
分类专栏： Java 文章标签： Lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jihaitaowangyi/article/details/52852693
版权

ReentrantLock也能够让代码块原子执行，但是比synchronized更加强大，ReentrantLock具有嗅探锁定、多路分支通知等功能。
嗅探锁定：是指获取锁时如果锁已经被其他线程获取到ReentrantLock可以进行指定等待时间获取锁或者
多路分支通知：是指线程发生await时，线程可以选择注册在不同的监视器Condition对象上，在适当的时候可以选择指定的监视器Condition对象上的线程进行signal通知、执行

1、多线程执行同一代码块互斥

import java.util.concurrent.locks.ReentrantLock;

class MyService {

    private ReentrantLock lock = new ReentrantLock();

    public void method() {
        try {
            lock.lock();
            for (int i = 1; i <= 3; i++) {
                Thread.sleep(1000);
                System.out.println("ThreadName=" + Thread.currentThread().getName() + "  " + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

class MyThread extends Thread {

    private MyService service;

    MyThread(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.method();
    }
}

public class Test {

    public static void main(String[] args) {
        MyService service = new MyService();
        MyThread myThread1 = new MyThread(service);
        MyThread myThread2 = new MyThread(service);

        myThread1.start();
        myThread2.start();
    }
}

结果
ThreadName=Thread-0 1
ThreadName=Thread-0 2
ThreadName=Thread-0 3
ThreadName=Thread-1 1
ThreadName=Thread-1 2
ThreadName=Thread-1 3

2、多线程执行不同代码块互斥


import java.util.concurrent.locks.ReentrantLock;

class MyService {
    private ReentrantLock lock = new ReentrantLock();

    public void methodA() {
        lock.lock();
        try {
            System.out.println("MethodA begin ThreadName=" + Thread.currentThread().getName());
            for (int i = 1; i <= 3; i++) {
                System.out.println("ThreadName=" + Thread.currentThread().getName() + "  " + i);
                Thread.sleep(1000);
            }
            System.out.println("MethodA end ThreadName=" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void methodB() {
        lock.lock();
        try {
            System.out.println("MethodB begin ThreadName=" + Thread.currentThread().getName());
            for (int i = 1; i <= 3; i++) {
                System.out.println("ThreadName=" + Thread.currentThread().getName() + "  " + i);
                Thread.sleep(1000);
            }
            System.out.println("MethodB end ThreadName=" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

class ThreadA extends Thread {

    private MyService service;

    ThreadA(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.methodA();
    }
}

class ThreadB extends Thread {

    private MyService service;

    ThreadB(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.methodB();
    }
}

public class Test {

    public static void main(String[] args) {
        MyService service = new MyService();
        ThreadA threadA = new ThreadA(service);
        threadA.setName("A");

        ThreadB threadB = new ThreadB(service);
        threadB.setName("B");
        threadA.start();
        threadB.start();
    }
}

结果：
MethodA begin ThreadName=A
ThreadName=A 1
ThreadName=A 2
ThreadName=A 3
MethodA end ThreadName=A
MethodB begin ThreadName=B
ThreadName=B 1
ThreadName=B 2
ThreadName=B 3
MethodB end ThreadName=B

3、多路通知

当多线程进入await状态时，利用Condition监视器对不同类型线程通知

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

class MyService {
    private ReentrantLock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();

    public void methodA() {
        lock.lock();
        try {
            System.out.println("MethodA begin ThreadName=" + Thread.currentThread().getName() + "  " + System.currentTimeMillis());
            conditionA.await();
            System.out.println("MethodA end ThreadName=" + Thread.currentThread().getName() + "  " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void methodB() {
        lock.lock();
        try {
            System.out.println("MethodB begin ThreadName=" + Thread.currentThread().getName() + "  " + System.currentTimeMillis());
            conditionB.await();
            System.out.println("MethodB end ThreadName=" + Thread.currentThread().getName() + "  " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signalA() {
        lock.lock();
        conditionA.signal();
        lock.unlock();
    }
    public void signalA_All() {
        lock.lock();
        conditionA.signalAll();
        lock.unlock();
    }


    public void signalB() {
        lock.lock();
        conditionB.signal();
        lock.unlock();
    }
    public void signalB_All() {
        lock.lock();
        conditionB.signalAll();
        lock.unlock();
    }
}

class ThreadA extends Thread {

    private MyService service;

    ThreadA(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.methodA();
    }
}

class ThreadB extends Thread {

    private MyService service;

    ThreadB(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.methodB();
    }
}

public class Test {

    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        ThreadA threadA = new ThreadA(service);
        threadA.setName("A");

        ThreadB threadB = new ThreadB(service);
        threadB.setName("B");
        threadA.start();
        threadB.start();

        Thread.sleep(1000);
        service.signalA();
        Thread.sleep(1000);
        service.signalB();

//        ThreadA[] threadAs = new ThreadA[10];
//        for (int i=0;i<5;i++){
//            threadAs[i] = new ThreadA(service);
//        }
//        ThreadB[] threadBs = new ThreadB[10];
//        for (int i=0;i<5;i++){
//            threadBs[i] = new ThreadB(service);
//        }
//
//        for (int i=0;i<5;i++){
//            threadAs[i].start();
//            threadBs[i].start();
//        }
//
//        Thread.sleep(1000);
//        service.signalA_All();
//        Thread.sleep(1000);
//        service.signalB_All();
    }
}

测试结果1：
MethodA begin ThreadName=A 1476800025028
MethodB begin ThreadName=B 1476800025029
MethodA end ThreadName=A 1476800026028
MethodB end ThreadName=B 1476800027028

修改代码为：

 public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
//        ThreadA threadA = new ThreadA(service);
//        threadA.setName("A");
//
//        ThreadB threadB = new ThreadB(service);
//        threadB.setName("B");
//        threadA.start();
//        threadB.start();
//
//        Thread.sleep(1000);
//        service.signalA();
//        Thread.sleep(1000);
//        service.signalB();

        ThreadA[] threadAs = new ThreadA[10];
        for (int i=0;i<5;i++){
            threadAs[i] = new ThreadA(service);
        }
        ThreadB[] threadBs = new ThreadB[10];
        for (int i=0;i<5;i++){
            threadBs[i] = new ThreadB(service);
        }

        for (int i=0;i<5;i++){
            threadAs[i].start();
            threadBs[i].start();
        }

        Thread.sleep(1000);
        service.signalA_All();
        Thread.sleep(1000);
        service.signalB_All();
    }

结果为：
MethodA begin ThreadName=Thread-0 1476800227416
MethodB begin ThreadName=Thread-7 1476800227417
MethodB begin ThreadName=Thread-5 1476800227417
MethodA begin ThreadName=Thread-3 1476800227418
MethodA begin ThreadName=Thread-1 1476800227418
MethodA begin ThreadName=Thread-4 1476800227418
MethodB begin ThreadName=Thread-6 1476800227418
MethodA begin ThreadName=Thread-2 1476800227418
MethodB begin ThreadName=Thread-8 1476800227418
MethodB begin ThreadName=Thread-9 1476800227418
MethodA end ThreadName=Thread-0 1476800228419
MethodA end ThreadName=Thread-3 1476800228419
MethodA end ThreadName=Thread-1 1476800228419
MethodA end ThreadName=Thread-4 1476800228420
MethodA end ThreadName=Thread-2 1476800228420
MethodB end ThreadName=Thread-7 1476800229419
MethodB end ThreadName=Thread-5 1476800229419
MethodB end ThreadName=Thread-6 1476800229419
MethodB end ThreadName=Thread-8 1476800229419
MethodB end ThreadName=Thread-9 1476800229419

4、公平所与非公平锁
公平锁是指线程获（getting）取锁的顺序和线程锁定（got）的顺序相同，

Lock的一些方法说明
A） getHoldCount()
获取当前锁定（got）的个数
B）getQueueLength()
获取当前正在等待获取（getting）锁的线程数（Threads）
C）getWaitQueueLength(Condition)
返回等待（await）与此锁定（got）的Condition相关的个数

燃烧一根
关注
  • 6
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java lock同步锁使用实例解析
08-25
主要介绍了Java lock同步锁使用实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
JavaSE复习之十二 高级特性：并发 (多线程) 补充（1）
十里の清风
03-25 247
 多线程u Threadu 线程创建u 线程池u 线程状态图第1章 多线程1.1 多线程介绍学习多线程之前，我们先要了解几个关于多线程有关的概念。进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。   线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这...
lock.lock() 写在 try 代码块内部行吗？
To be a great coder
08-05 9093
熟悉 Java 并发的朋友，想必都会对 Lock 接口很熟悉，它是从 JDK1.5 以后提供给开发者的另一种线程同步的方式。下面是使用它的一个具体实现类：ReentrantLock 进行加锁解锁的一个小例子： Lock lock = new ReentrantLock(); lock.lock(); try { // access the resource protected by t...
java Lock锁详解
最新发布
qq_42077317的博客
03-11 1065
1.公平锁：就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己。await(long time, TimeUnit unit)：使当前线程等待一段时间，在指定的时间内没有被其他线程调用signal()或signalAll()方法唤醒，将自动唤醒。await()：使当前线程等待，直到被其他线程调用signal()或signalAll()方法唤醒。
Java-多线程-模拟电影买票-同步代码块，Lock锁
weixin_62971115的博客
08-02 163
假设共100张票，共有三个柜台售卖。
Java电商平台之订单功能和支付功能实现
weixin_42354197的博客
07-07 8505
下单支付流程 1.选择商品添加至购物车。 2.点击支付，创建订单。 3.将订单写入数据库。 4.同时扣减库存，将订单数据同时同步到redis，并且设置过期时间。 5.取消订单(超时未支付)，退回商品库存。 6.定时清理未支付异常订单，退回商品库存。 订单中遇到的问题： 1.重复下单，恶习重复下单， 2.如何安全扣减库存，不超卖不少卖 redis队列采用fifo先进先出算法实现。 ...
4 浅谈JAVA 中的锁
weixin_43643617的博客
03-14 1028
1 悲观锁和乐观锁 1.1 悲观锁 定义 认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改。 synchronized关键字和Lock的实现类都是悲观锁 适合场景 适合写操作多的场景，先加锁可以保证写操作时数据正确。 代码 //=============悲观锁的调用方式 public synchronized void m1() { //加锁后的业务逻辑...... } // 保证多个线程使用的是同一个lock对象的前提下 Reen
java自定义lock锁
ITzhongzi的博客
09-14 612
java自定义lock锁
Java中的Lock详解
向上的"狼"的博客
04-28 2万+
简介 java.util.concurrent.locks.Lock 是一个类似于synchronized 块的线程同步机制。但是 Lock比 synchronized 块更加灵活。Lock是个接口，有个实现类是ReentrantLock。 Lock和syncronized的区别
Java常见锁（公平锁、非公平锁、可重入锁、自旋锁、独占锁、共享锁）
m0_37695902的博客
02-20 688
Java常见锁（公平锁、非公平锁、可重入锁、自旋锁、独占锁、共享锁）
Java分布式锁的几种实现
FREEDOM
06-03 1157
无论你身处一个什么样的公司，最开始的工作可能都需要从最简单的做起。不要提阿里和腾讯的业务场景 qps 如何大，因为在这样的大场景中你未必能亲自参与项目，亲自参与项目未必能是核心的设计者，是核心的设计者未必能独自设计。希望大家能根据自己公司业务场景，选择适合自己项目的方案。
Java锁机制Lock用法示例
08-27
主要介绍了Java锁机制Lock用法,结合具体实例形式分析了Java锁机制的相关上锁、释放锁、隐式锁、显式锁等概念与使用技巧,需要的朋友可以参考下
Java多线程中Lock锁的使用总结
08-18
主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java的Lock小结
12-15
本文总结了Java中Lock的各种用法。
Java Lock接口实现原理及实例解析
08-19
主要介绍了Java Lock接口实现原理及实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java锁--可重入锁
比利的博客
10-14 632
java锁--可重入锁
java 中 Lock
春风化雨
01-12 347
Lock 是一个接口，定义锁的基础规范，它比同步方法和同步块提供了更具扩展性的锁操作；这些方法允许更灵活的结构，可以具有完全不同的性质，并且可以支持多个相关类的条件对象。 package java.util.concurrent.locks; import java.util.concurrent.TimeUnit; public interface Lock { void lock(); void lockInterruptibly() throws InterruptedExc
详解JAVA中的构造方法
热门推荐
m0_70322372的博客
11-13 3万+
三千字详解JAVA中的构造方法
Java的锁：公平锁，非公平锁，可重入锁，自旋锁，独占锁（写锁） / 共享锁（读锁） / 互斥锁...
这个时代，作为程序员可能要学习小程序
10-08 254
点击上方关注 “终端研发部”设为“星标”，和你一起掌握更多数据库知识公平锁和非公平锁公平锁是指多个线程按照申请锁的顺序来获取锁，类似于排队买饭，先来后到，先来先服务，就是公平的，也就是队列...
Java trylock 使用
05-19
Java中的`tryLock()`方法是一个非阻塞式的获取锁的方法，它会尝试获取锁，如果锁当前没有被其他线程持有，那么它会立即获取锁并返回true，否则它会立即返回false。如果你想要使用`tryLock()`方法来获取锁，首先需要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值