java的中的各种锁

最新推荐文章于 2024-07-15 15:16:01 发布
最新推荐文章于 2024-07-15 15:16:01 发布
阅读量7.4k 收藏 2
点赞数
分类专栏： B-java基础+jvm+并发+设计模式 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wozniakzhang/article/details/108046261
版权

Synchronzied与ReentrantLock(Lock接口的一个实现类)的对比

ReentrantLock有很多 Synchronzied 不具备的功能,下文展示一些实现lock的实现类,记住一些典型案例

 演示锁-ReentrantLock基本使用示例代码如下(重要的事情是解锁哈)

package com.example.java.base.concurrency.lock.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
/**
 * ReentrantLockTest:ReentrantLock锁的基本使用默认是非公平的锁(可以通过构造方法传入true改为公平锁)
 * Lock不会像synchronized一样，异常的时候自动释放锁，所以最佳实践是，finally中释放锁，以便保证发生异常的时候锁一定被释放
 * 关于synchronized与ReentrantLock对比和选择,在java并发编程与实战的书上是解释得很清楚了,当然也可以参考网上相关博客
 *
 * @author zhangxiaoxiang
 * @date 2020/11/14
 */
public class ReentrantLockTest {
    private static Lock lock = new java.util.concurrent.locks.ReentrantLock();
 
    public static void main(String[] args) {
        System.out.println("先获取锁");
        //锁【lock.lock】必须紧跟try代码块，且unlock要放到finally第一行。
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "开始执行任务(这里是业务代码)");
        } finally {
            lock.unlock();
            System.out.println("要记得在 try的 finally 里面显示的释放锁哦");
        }
    }
}

演示锁-ReentrantLock调用tryLock()方法来避免死锁示例代码

package com.example.java.base.concurrency.lock.lock;

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

/**
 * ReentrantLockTryLockTest:
 * 用tryLock来避免死锁
 *
 * @author zhangxiaoxiang
 * @date 2020/11/14
 */
public class ReentrantLockTryLockTest implements Runnable {

    /**
     * 标记位
     */
    int flag = 1;
    static Lock lock1 = new ReentrantLock();
    static Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        ReentrantLockTryLockTest r1 = new ReentrantLockTryLockTest();
        ReentrantLockTryLockTest r2 = new ReentrantLockTryLockTest();
        r1.flag = 1;
        r1.flag = 0;
        //不要显式创建线程，请使用线程池。(演示图个方便)
        new Thread(r1).start();
        new Thread(r2).start();

    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (flag == 1) {
                try {
                    if (lock1.tryLock(800, TimeUnit.MILLISECONDS)) {
                        try {
                            System.out.println("线程1获取到了锁1");
                            Thread.sleep(new Random().nextInt(1000));
                            if (lock2.tryLock(800, TimeUnit.MILLISECONDS)) {
                                try {
                                    System.out.println("线程1获取到了锁2");
                                    System.out.println("线程1成功获取到了两把锁");
                                    break;
                                } finally {
                                    lock2.unlock();
                                    System.out.println("---lock2.unlock()---");
                                }
                            } else {
                                System.out.println("线程1获取锁2失败，已重试");
                            }
                        } finally {
                            lock1.unlock();
                            System.out.println("---lock1.unlock()---");
                            Thread.sleep(new Random().nextInt(1000));
                        }
                    } else {
                        System.out.println("线程1获取锁1失败，已重试");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            if (flag == 0) {
                try {
                    if (lock2.tryLock(3000, TimeUnit.MILLISECONDS)) {
                        try {
                            System.out.println("线程2获取到了锁2");
                            Thread.sleep(new Random().nextInt(1000));
                            if (lock1.tryLock(800, TimeUnit.MILLISECONDS)) {
                                try {
                                    System.out.println("线程2获取到了锁1");
                                    System.out.println("线程2成功获取到了两把锁");
                                    break;
                                } finally {
                                    lock1.unlock();
                                    System.out.println("---lock1.unlock()---");
                                }
                            } else {
                                System.out.println("线程2获取锁1失败，已重试");
                            }
                        } finally {
                            lock2.unlock();
                            System.out.println("---lock2.unlock()---");
                            Thread.sleep(new Random().nextInt(1000));
                        }
                    } else {
                        System.out.println("线程2获取锁2失败，已重试");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

 

演示锁-ReentrantLock调用lockInterruptibly()方法

package com.zhang.myjuc.a3.lock.lock;

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

/**
 * ReentrantLockInterruptiblyDemo:可中断锁
 * @author zhangxiaoxiang
 * @date 2020/8/16
 */
public class ReentrantLockInterruptiblyDemo implements Runnable {

    private Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        ReentrantLockInterruptiblyDemo lockInterruptibly = new ReentrantLockInterruptiblyDemo();
        Thread thread0 = new Thread(lockInterruptibly);
        Thread thread1 = new Thread(lockInterruptibly);
        thread0.start();
        thread1.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread1.interrupt();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "尝试获取锁");
        try {
            lock.lockInterruptibly();
            try {
                System.out.println(Thread.currentThread().getName() + "获取到了锁");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + "睡眠期间被中断了");
            } finally {
                lock.unlock();
                System.out.println(Thread.currentThread().getName() + "释放了锁");
            }
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + "获得锁期间被中断了");
        }
    }
}

ReentrantLock 可重入锁-应用场景(订电影票)

package com.zhang.myjuc.a3.lock.reentrantlock;

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

/**
 * CinemaBookSeat:演示多线程预定电影票
 *
 * @author zhangxiaoxiang
 * @date 2020/08/16
 */
public class CinemaBookSeat implements Runnable{
    private static ReentrantLock lock=new ReentrantLock();
    private static void bookSeat(){

    }
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        //这里显示的创建可以更加熟悉线程池的参数,最重要的是那个队列长度(默认是整形类最大值,搞不好容易OOM),
        // 符合阿里规范,表示这里有4个核心线程,如果不够用就增加至8个,存货时间是60秒,之后不用 就回收,节省资源
        ThreadPoolExecutor executor = new ThreadPoolExecutor(4,
                8, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(5));
        //这里模拟多个线程订票
        for (int i = 0; i < 10; i++) {
            service.submit(new CinemaBookSeat());
        }
    }
    @Override
    public void run() {
        lock.lock();
        try {
            System.out.println("用户"+Thread.currentThread().getName()+" 开始预定座位,为你锁定座位3秒钟,如果不买自动释放");
            Thread.sleep(3000);
            System.out.println("用户"+Thread.currentThread().getName()+" 买票订座完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

 ReentrantLock  可重入锁-演示公平和非公平的情况

package com.zhang.myjuc.a3.lock.reentrantlock;

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

/**
 * FairLock:演示公平和不公平两种情况  注意构造函数和结果的对比,,主要注意0线程持有锁后是立即执行还是在队列后执行
 *
 * @author zhangxiaoxiang
 * @date 2020/8/17
 */
public class FairLock {

    public static void main(String[] args) {
        PrintQueue printQueue = new PrintQueue();
        Thread thread[] = new Thread[10];
        for (int i = 0; i < 10; i++) {
            thread[i] = new Thread(new Job(printQueue));
        }
        for (int i = 0; i < 10; i++) {
            thread[i].start();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Job implements Runnable {

    PrintQueue printQueue;

    public Job(PrintQueue printQueue) {
        this.printQueue = printQueue;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "排队中...");
        printQueue.printJob(new Object());
        System.out.println(Thread.currentThread().getName() + "打印完毕---ok");
    }
}

class PrintQueue {

    private Lock queueLock = new ReentrantLock(false);

    public void printJob(Object document) {
        queueLock.lock();
        try {
            int duration = new Random().nextInt(5) + 1;
            System.out.println(Thread.currentThread().getName() + "第一份-----正在打印，需要" + duration + "秒");
            Thread.sleep(duration * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            queueLock.unlock();
        }

        queueLock.lock();
        try {
            int duration = new Random().nextInt(5) + 1;
            System.out.println(Thread.currentThread().getName() + "第二份-----正在打印，需要" + duration + "秒");
            Thread.sleep(duration * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            queueLock.unlock();
        }
    }
}

 上面代码运行结果

ReentrantReadWriteLock 读写锁-演示可以共读,但是不可共写

package com.zhang.myjuc.a3.lock.readwrite;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * CinemaReadWrite:读写锁示例(电影院示例升级)
 *
 * @author zhangxiaoxiang
 * @date 2020/08/16
 */
public class CinemaReadWrite {
    private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
    private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();

    private static void read() {
        //获取读锁
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 得到了读锁,正在读取");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放读锁
            readLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 释放了读锁");
        }
    }

    private static void write() {
        //获取写锁
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 得到了写锁,正在写入");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放写锁
            writeLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 释放了写锁");
        }
    }


    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
                5, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(5));
        //这里由于要为线程添加名字,所以这么写(和视频不一样)
        executor.submit(new Thread(() -> read(), "Thead1"));
        executor.submit(new Thread(() -> read(), "Thead2"));
        executor.submit(new Thread(() -> write(), "Thead3"));
        executor.submit(new Thread(() -> write(), "Thead4"));
    }
}

 自旋锁 在代码里面体现

package com.zhang.myjuc.a3.lock.spinlock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * SpinLock:自旋锁
 *
 * @author zhangxiaoxiang
 * @date 2020/08/16
 */
public class SpinLock {
    /**
     * AtomicReference 可以自动更新的对象引用
     */
    private AtomicReference<Thread> sign = new AtomicReference<>();

    /**
     * 模拟加锁
     */
    public void lock() {
        Thread thread = Thread.currentThread();
        //自旋锁这里用到了CAS 如果当前值==预期值，则自动将该值设置为给定的更新值。
        while (!sign.compareAndSet(null, thread)) {
            //放开注释展示消耗过程
            // System.out.println("自旋锁获取失败,再次尝试");
        }
    }

    /**
     * 模拟释放锁
     */
    public void unlock() {
        Thread currentThread = Thread.currentThread();
        sign.compareAndSet(currentThread, null);
    }

    //测试方法
    public static void main(String[] args) {
        SpinLock spinLock = new SpinLock();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 开始尝试获取自旋锁");
                spinLock.lock();
                System.out.println(Thread.currentThread().getName() + " 获取到了自旋锁");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    spinLock.unlock();
                    System.out.println(Thread.currentThread().getName() + " 释放了自旋锁");
                }
            }
        };
        Thread thread = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        thread.start();
        thread2.start();
    }
}

代码运行结果

 锁的降级和非公平和公平的ReentrantReadWriteLock的策略  待补充...

张晓祥-长草颜团子
关注
专栏目录
Java中各种锁的相关知识点(含代码)
qq_57469718的博客
04-11 454
公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解，请手写一个自旋锁 公平锁：是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到 非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁在高并发的情况下，有可能会造成优先级反转或者饥饿现象 并发包中ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁，默认是非公平锁，非公平锁的优点在于吞吐量比公平锁大。对于Synchronized而言，也是一种
Java中的各种锁
weixin_53818213的博客
09-20 766
乐观锁、悲观锁、共享锁、独占锁、公平锁、非公平锁、可重入锁、互斥锁、读写锁、分段锁、同步锁、死锁、自旋锁、锁粗化、锁消除、重量级锁、偏向锁、轻量级锁
java锁的代码
ITjingxinbao的博客
04-05 178
java练习
java开发中常见锁的使用场景和代码示例
最新发布
weixin_45235440的博客
07-15 2399
线程同步和并发控制
java 阻塞_Java锁的种类以及辨析（三）：阻塞锁
weixin_33460449的博客
02-12 197
作者：山鸡锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等等 ) 。这些已经写好提供的锁为我们开发提供了便利，但是锁的具体性质以及类型却很少被提及。本系列文章将分析JAVA下常见的锁名称以及特性，为大家答疑解惑。三、阻塞锁：阻塞锁，与自旋锁不同，改变了线程的运行状态。在JAVA环境中，线程Thread有如下几个状态：1，...
Java 中的锁
博客只为自己学习提升纪录所用，如有侵权或不妥之处，还请私信删除！加油
05-19 417
Java 中各种锁的概念
java加锁代码例子,JAVA锁之可重入锁和递归锁及示例代码
weixin_42223120的博客
03-21 205
概念：可重入锁指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块示例代码：package com.debuggg.test1.main4;import java.util.concurrent.locks.Lock;import java.util.concur...
彻底理解Java中的各种锁.pdf
06-18
通过以上对Java锁机制的详细介绍，可以看出Java在并发控制方面具有丰富的工具和策略，它们能够帮助开发者在多线程编程中处理好资源竞争和线程协作的问题，从而编写出高效且线程安全的应用程序。
介绍了java中各种存在的锁机制、面试必备
07-28
本文将深入探讨Java中各种锁的实现方式，以及它们在面试中常见的考点。 首先，最基本的锁是`synchronized`关键字，它提供了两种用法：同步方法和同步代码块。同步方法通过在方法声明上添加`synchronized`来实现，...
Java中的锁分类的详细介绍
08-29
Java 中的锁分类可以分为多种类型，包括公平锁、非公平锁、可重入锁、独享锁、共享锁、互斥锁、读写锁、乐观锁、悲观锁、分段锁、偏向锁、轻量级锁、重量级锁、自旋锁等。这些锁的分类并不是指锁的状态，有的指锁的...
阿里面试失败后，一气之下我图解了Java中18把锁
热门推荐
华科硕士，大厂打工中。编程问题咨询，请私我
06-17 41万+
目录 乐观锁和悲观锁 独占锁和共享锁 互斥锁和读写锁 公平锁和非公平锁 可重入锁 自旋锁 分段锁 锁升级（无锁|偏向锁|轻量级锁|重量级锁） 锁优化技术（锁粗化、锁消除） 乐观锁和悲观锁 悲观锁 悲观锁对应于生活中悲观的人，悲观的人总是想着事情往坏的方向发展。 举个生活中的例子，假设厕所只有一个坑位了，悲观锁上厕所会第一时间把门反锁上，这样其他人上厕所只能在门外等候，这种状态就是「阻塞」了。 回到代码世界中，一个共享数据加了悲观锁，那线程每次想操作这个数据前都会假设其他线程.
JAVA Lock加锁实例
07-10
Lock锁是对象锁，仅在同一对象中，锁才会生效。（不做论证） （以下场景皆为单例模式下运行） lock.lock()的加锁方式，会使后续请求的线程堵塞等待。（方案A） lock.tryLock()的加锁方式，不会堵塞，会立即返回加锁成功与否。（方案AEX） lock.tryLock(1000, TimeUnit.SECONDS)的加锁方式，允许堵塞时间，若在堵……
Java各种锁
wuhuagu_wuhuaguo的博客
03-05 3380
一、读写锁(ReentrantReadWriteLock) 二、非公平锁(synchronized/ReentrantLock) 三、可重入锁/递归锁(synchronized/ReentrantLock) 四、自旋锁(spinlock) 五、乐观锁/悲观锁 六、死锁
Java中的锁大全(底层源码分析)
weixin_42754971的博客
02-17 1593
转自：https://tech.meituan.com/2018/11/15/java-lock.html 前言 Java提供了种类丰富的锁，每种锁因其特性的不同，在适当的场景下能够展现出非常高的效率。本文旨在对锁相关源码（本文中的源码来自JDK 8和Netty 3.10.6）、使用场景进行举例，为读者介绍主流锁的知识点，以及不同的锁的适用场景。 Java中往往是按照是否含有某一特性来定义锁，我们通过特性将锁进行分组归类，再使用对比的方式进行介绍，帮助大家更快捷的理解相关知识。下面给出本文内容的总体分类.
JAVA中的部分锁
qq_41543575的博客
06-22 227
JAVA中的锁 一、公平锁与非公平锁 公平锁：每一个线程在来到公平锁时，先查看该锁是否被占有了，如果被占用了则到等待队列的队尾进行排队;若该锁是空的则占有该锁。 非公平锁：就是正在排着队的线程，突然遭到另一个线程的抢夺，若能抢夺成功则优先执行，否则和公平锁一样再回到队尾排队。 典型的非公平锁： Lock lock = new ReentrantLock(); //当使用无参构造器时 其底层默认是非公平锁 Lock lock = new ReentrantLock(true); //当使用有参数的构造
java 代码块锁_java 多线程9 : synchronized锁机制 之 代码块锁
weixin_31955925的博客
02-12 254
synchronized同步代码块用关键字synchronized声明方法在某些情况下是有弊端的，比如A线程调用同步方法执行一个较长时间的任务，那么B线程必须等待比较长的时间。这种情况下可以尝试使用synchronized同步语句块来解决问题。看一下例子：下面例子是优化后的例子 使用代码块锁，原先例子是方法锁，就是同步 必须要执行2个forpublic classThreadDomain18{pu...
java 锁 代码,Java锁机制（二）(示例代码)
weixin_31508009的博客
03-14 78
CAS无锁机制CAS：Compare and Swap，即比较再交换。Java内存模型：JMM(Java Memory Model)在内存模型当中定义了一个主内存，所有声明的实例变量都存在于主内存当中，主内存的数据会共享给所有线程，每一个线程有一块工作内存，工作内存当中主内存数据的副本当更新数据时，会将工作内存中的数据同步到主内存当中CAS无锁机制：本身无锁，采用乐观锁的思想，在数据操作时对比数据...
Java锁的全面认识和相关锁测试代码
XuJiaKai的博客
08-21 462
Java锁的认识和synchronized的底层分析,锁升级概念和详细分析,juc下锁的测试代码等等
说说java中的各种锁
04-05
Java中有多种锁，可以根据应用场景的不同选择不同的锁。 1. synchronized锁：synchronized是Java中最基本的锁。它是一种互斥锁，同一时间只能有一个线程持有该锁，其他线程必须等待该线程释放锁才能获得锁。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值