java中的锁

最新推荐文章于 2024-07-16 17:32:14 发布
最新推荐文章于 2024-07-16 17:32:14 发布
阅读量814 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34983808/article/details/101173174
版权

引言

在java单线程中，并不会出现资源抢夺的现象，但是在多线程并发中，会出现资源抢夺现象。为了避免这种情况需要上锁

分类

可重入锁，又名递归锁

指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁，也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。

使用synchronized

class Phone{

    public void sendSMS() {
        System.out.println(Thread.currentThread().getName() "\t invoked sendSMS()");
        sendEmail();
    }

    private void sendEmail() {
        System.out.println(Thread.currentThread().getName() "\t ###########invoked sendEmail()");
    }
}
public class ReentrantLockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sendSMS();
        },"t1").start();

        new Thread(()->{
            phone.sendSMS();
        },"t2").start();
    }
}

结果

t1     invoked sendSMS()    //t1线程在外层方法获取锁的时候
t1     ###########invoked sendEmail()     //t1在线程进入内层方法会自动获取锁
t2     invoked sendSMS()
t2     ###########invoked sendEmail()

使用ReentrantLock

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

class Phone implements Runnable {


    Lock lock = new ReentrantLock();

    public void sendSMS() {
        System.out.println(Thread.currentThread().getName()   "\t invoked sendSMS()");
        sendEmail();
    }

    private void sendEmail() {
        System.out.println(Thread.currentThread().getName()   "\t ###########invoked sendEmail()");
    }

    @Override
    public void run() {
        get();
    }

    public void get() {
        lock.lock();
        try{
            System.out.println(Thread.currentThread().getName()   "\t invoked get()");
            set();
        }catch (Exception e){

        }finally {
            lock.unlock();
        }

    }

    private void set() {
        lock.lock();
        try{
            System.out.println(Thread.currentThread().getName()   "\t invoked set()");
        }catch (Exception e){

        }finally {
            lock.unlock();
        }
    }
}

public class ReentrantLockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendSMS();
        }, "t1").start();

        new Thread(() -> {
            phone.sendSMS();
        }, "t2").start();


        //暂停一会线程
        try {
            TimeUnit.MICROSECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println();
        
        Thread t3 = new Thread(phone,"t3");
        Thread t4 = new Thread(phone,"t4");
        t3.start();
        t4.start();

    }
}

结果

t1     invoked sendSMS()
t1     ###########invoked sendEmail()
t2     invoked sendSMS()
t2     ###########invoked sendEmail()




t3     invoked get()
t3     invoked set()
t4     invoked get()
t4     invoked set()

自旋锁

CAS循环比较并交换

是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class SpinLockDemo {

    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()   "\t come in...");
        while (!atomicReference.compareAndSet(null, thread)) {

        }

    }

    public void myUnLock() {

        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        System.out.println(Thread.currentThread().getName()   "\t invoked myUnLock()");

    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.myLock();
            //暂停一会线程
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            spinLockDemo.myUnLock();

        }, "AA").start();


        //暂停一会线程
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(() -> {
            spinLockDemo.myLock();

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            spinLockDemo.myUnLock();

        }, "BB").start();

    }
}

结果

AA     come in...
BB     come in...
AA     invoked myUnLock()
BB     invoked myUnLock()

读写锁

读时共享资源数据，写时独占资源数据

多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行，但是如果有一个线程想去写共享资源，就不应该再有其它线程可以对该资源进行读或写。

读-读能共存

读-写不能共存

写-写不能共存

没有使用读写锁前

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

class MyCache{
    private volatile Map<String,Object> map=new HashMap<>();


    public void put(String key, String value) {
        System.out.println(Thread.currentThread().getName() "\t 正在写入：" key);
        //暂停一会线程
        try {
            TimeUnit.MICROSECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key,value);
        System.out.println(Thread.currentThread().getName() "\t 写入完成：");

    }

    public void get(String key) {
        System.out.println(Thread.currentThread().getName() "\t 正在读取：");
        //暂停一会线程
        try {
            TimeUnit.MICROSECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Object result = map.get(key);
        System.out.println(Thread.currentThread().getName() "\t 读取完成：" result);
    }
}
public class ReadWriteDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        //创建5个线程,写入资源数据
        for(int i=1;i<=5;i  ){
            final  int tempInt = i;
            new Thread(()->{
                myCache.put(tempInt "",tempInt "");
            },String.valueOf(i)).start();
        }


        //创建5个线程,读取资源数据
        for(int i=1;i<=5;i  ){
            final  int tempInt = i;
            new Thread(()->{
                myCache.get(tempInt "");
            },String.valueOf(i)).start();
        }
    }
}

结果

写时并不满足原子性和独占性，整个过程必须是一个完整的统一体，中间不允许被分割，被打断

5     正在写入：5
1     正在写入：1
3     正在写入：3
2     正在读取：
4     正在写入：4
2     正在写入：2
1     正在读取：
5     正在读取：
3     正在读取：
4     正在读取：
2     写入完成：
5     读取完成：5
5     写入完成：
4     读取完成：null
2     读取完成：null
3     写入完成：
1     读取完成：null
1     写入完成：
3     读取完成：3
4     写入完成：

使用读写锁后

使用ReentrantReadWriteLock

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

class MyCache {
    private volatile Map<String, Object> map = new HashMap<>();

    //读写锁
    private ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();


    public void put(String key, String value) {

        rwlock.writeLock().lock();
        try {

            System.out.println(Thread.currentThread().getName()   "\t 正在写入："   key);
            //暂停一会线程
            try {
                TimeUnit.MICROSECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName()   "\t 写入完成：");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rwlock.writeLock().unlock();
        }


    }

    public void get(String key) {

        rwlock.readLock().lock();
        try {

            System.out.println(Thread.currentThread().getName()   "\t 正在读取：");
            //暂停一会线程
            try {
                TimeUnit.MICROSECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName()   "\t 读取完成："   result);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rwlock.readLock().unlock();
        }
    }
}

public class ReadWriteDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        //创建5个线程,写入资源数据
        for (int i = 1; i <= 5; i  ) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(tempInt   "", tempInt   "");
            }, String.valueOf(i)).start();
        }


        //创建5个线程,读取资源数据
        for (int i = 1; i <= 5; i  ) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.get(tempInt   "");
            }, String.valueOf(i)).start();
        }
    }
}

结果

4     正在写入：4
4     写入完成：
2     正在写入：2
2     写入完成：
1     正在写入：1
1     写入完成：
3     正在写入：3
3     写入完成：
5     正在写入：5
5     写入完成：
1     正在读取：
4     正在读取：
2     正在读取：
3     正在读取：
5     正在读取：
3     读取完成：3
1     读取完成：1
5     读取完成：5
2     读取完成：2
4     读取完成：4

参考

一道面试题比较synchronized和读写锁 - where - ITeye博客

qq_34983808
关注
专栏目录
Java中锁的分类
@龙猫的博客
04-12 3426
Java中锁的分类1、可重入锁/不可重入锁2、可中断锁3、公平锁/非公平锁4、独享锁（互斥锁）/共享锁（读写锁）5、乐观锁/悲观锁6、分段锁7、偏向锁/轻量级锁/重量级锁8、自旋锁 先来一段很常见的死锁代码： class Deadlock { public static String str1 = "str1"; public static String str2 = "str2"...
java中锁的四种状态
m0_69523172的博客
04-29 1922
四种状态 锁状态转换过程 锁的优缺点 参考文章 小结 [](()前言 ============================================================ 在多线程并发编程中Synchronized一直是元老级角色，很多人都会称它为重量级锁，但是随着 Java SE1.6 对 Synchronized 进行了各种优化之后，有些情况下它并不那么重了，本文详细介绍了 Java SE1.6 中为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁，..
Java中常用的锁总结与理解
热门推荐
张彦峰的博客
05-12 166万+
对java锁相关内容进行整理分析：乐观锁 VS 悲观锁+自旋锁 VS 适应性自旋锁+无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁+公平锁 VS 非公平锁+可重入锁 VS 非可重入锁+独享锁 VS 共享锁
java中锁的详解
清雨小竹
05-26 2525
因此，重量级锁的开销较大，可能会导致线程阻塞和性能下降。但是，由于重量级锁提供了最高的线程安全性，所以在需要确保数据完整性和一致性的情况下，重量级锁是非常有用的。但是，由于轻量级锁不是互斥的，所以如果多个线程同时尝试获取锁，则可能导致数据不一致的问题。可重入锁(Reentrant Lock):可重入锁允许同一个线程多次获取同一个锁，这意味着线程可以在执行完同步代码后再次获取该锁而不需要重新竞争。自旋锁(Spin Lock):自旋锁是一种基于忙等待的同步机制，它在获取锁时会一直循环等待，直到获取到锁为止。
深入解析Java中锁机制以及底层原理
码星人
03-13 2283
深入分析了Java各种锁的机制和原理
java中锁的面试题
m0_52767002的博客
02-16 1万+
1. synchronized锁（悲观锁、同步锁） synchronized关键字：表示“同步”的。它可以对“多行代码”进行“同步”——将多行代码当成是一个完整的整体，一个线程如果进入到这个代码块中，会全部执行完毕，执行结束后，其它线程才会执行。这样可以保证这多行的代码作为完整的整体，被一个线程完整的执行完毕。 synchronized被称为“重量级的锁”方式，也是“悲观锁”——效率比较低。 1.1synchronized有几种使用方式： a).同步代码块【常用】 b).同步方法【常
java锁详解
最新发布
SRY12240419的博客
07-16 2257
java当中的锁、是在多线程环境下为保证共享资源健康、线程安全的一种手段。 线程操作某个共享资源之前，先对资源加一层锁，保证操作期间没有其他线程访问资源，当操作完成后，再释放锁。
Java中锁种类、实现方式
weixin_40482816的博客
03-08 4483
锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现。如 synchronized 和 ReentrantLock（并发包中的锁类）等 。 1、锁涉及的几个重要概念 死锁 线程之间相互等着对方释放资源，而自己的资源又不释放给别人，这种情况就是死锁。所以，只要其中一线程释放了资源，死锁就会被解除。 重入锁 重入锁指的是，一个线程在拥有了当前资源的锁之后，可以再次拿到该锁而不被阻塞。在后面会讲到synchronized的重入锁原理。 自旋锁 自旋锁指的是，线程在没有获得锁时，不是被直接挂起，而
java中常见的锁
hackerlee
07-11 1813
java常见的锁类型及用法
java中的锁机制
jh_554的博客
07-27 2957
java中的锁相关知识梳理笔记
java 中锁的性能提高办法
08-31
【Java 中锁的性能提高办法】 在 Java 多线程编程中，锁是实现线程安全的关键机制。然而，不当的锁使用可能会导致性能瓶颈，甚至引发死锁等问题。以下是一些提高 Java 中锁性能的技术和策略： 1. **分离锁（Lock ...
JAVA中锁概及运用.doc
09-30
JAVA 中锁概及运用 JAVA 中锁是指在多线程环境下，用于控制对共享资源的访问的机制。锁是 Java 并发编程的核心概念之一，锁机制可以确保在多线程环境下，共享资源不会被多个线程同时访问，从而避免数据不一致和其他...
Java中锁的实现和内存语义浅析
08-26
在Java并发编程中，锁的实现和内存语义是实现线程安全的关键机制之一。锁的机制能够保证在多线程环境中，对于共享资源的访问互斥执行，防止出现数据竞争和条件竞争的问题。而内存语义涉及到线程间如何通过主内存和...
vscode主题安装
qq_34983808的博客
09-22 4455
安装主题 快捷键Ctrl Shift X打开安装插件 搜索Monokai ST3 切换主题 显示效果 安装文件图标 扩展插件vscode-icon 鼠标滚轮设置字体大小 打开setting.json文件 修改setting.json,追加"editor.mouseWheelZoom": true { "editor.fontSize": 16, "workben...
gradle 转换spring源码成eclipse工程
qq_34983808的博客
03-09 1602
1、下载spring源码方式： 方式一、通过Git客户端下载： C:\Users\libingshen&gt;git clone https://github.com/spring-projects/spring-framework.git 方式二、通过eclipse的svn检出： 2、spring源码转换成eclipse工程 方式一：转换通过Git客户端下载的spring源码 进...
oracle定时执行存储过程
qq_34983808的博客
11-21 1371
需求 每小时进行一次查询统计数据，并将数据插入到自定义的表当中 效果 创建存储过程 create or replace procedure summary_data as v_dcppv number; v_jd12h number; v_dby number; v_xby number; v_bj number; v_bn number; v...
订单唯一标识
qq_34983808的博客
09-25 1273
在平常开发系统，设计表结构的时候，常常需要有一个字段来标识该条记录的唯一性，从java层面和数据库层面不同维度来进行实现 java生成唯一标识 版本一 java自带生成唯一标识UUID System.out.println(UUID.randomUUID().toString()); 输出 4880d2b4-bc5f-48d1-ba58-003334276d46 明显地看出来太长了...
HttpClient远程接口调用-实名认证
qq_34983808的博客
09-22 1108
1、HttpClient远程接口调用 1)用户注册 注册按钮button提交表单时，要return false form表单 <!-- action="http://localhost:8082/scw-restapi/member/regist" --> <form class="form-signin" role="form" action="${ctp...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值