Java 锁的理解

最新推荐文章于 2023-09-18 15:03:14 发布
最新推荐文章于 2023-09-18 15:03:14 发布
阅读量2.2k 收藏
点赞数
分类专栏： # JUC并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woo_home/article/details/107876341
版权

文章目录

公平锁与非公平锁

    用过并发包的朋友对这个应该不会陌生，ReentrantLock 是 Java 的 JUC（java.util.concurrent）包中提供的一种可重入锁，是一种递归无阻塞的同步机制。ReentrantLock 等同于synchronized关键字，但是 ReentrantLock 提供了比 synchronized 更强大，更灵活的锁机制，可以减少死锁发生的概率

在这里插入图片描述

非公平锁

    ReentrantLock 还提供了公平锁（fair）和非公平锁（unfair）。非公平锁是当锁被释放的时候，等待中的线程均有机会获得锁。有可能后申请的线程比先申请的线程优先获取锁，在高并发的情况下，有可能会造成优先级反转或者饥饿现象synchronized是非公平锁，而 ReentrantLock 也是一样。但是 ReentrantLock 可以通过构造方法接收一个可选的fair参数（默认是非公平锁）
在这里插入图片描述

公平锁

所谓的公平锁就是指锁的获取策略相对公平，当多个线程在获取同一个锁的时候，必须按照锁的申请时间来一次获得锁，也就是按顺序来

在这里插入图片描述
当传入的值为 true 时则表示是公平锁，源码如下：
在这里插入图片描述

关于公平锁与非公平锁的区别

  • 公平锁：就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当线程是等待队列的第一个，就占有锁。否则就会加入到等待队列中，以后会按照 FIFO（先进先出原则）从队列中获取到自己
  • 非公平锁：非公平比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁的那种方式

对于 ReentrantLock 而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大

对于 synchronized 而言，也是一种非公平锁

可重入锁（也叫作递归锁）

指的是同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁

简单地说，线程可以进入任何一个它已经拥有的锁所同步着的代码块

举例

package concurrency.day0411;

/**
 * @author Woo_home
 * @create by 2020/4/11  20:06
 */

// 线程操纵资源类
class ThreadDemo {
	// 定义一个同步方法
    public synchronized void seyHello() {
        System.out.println(Thread.currentThread().getName() + " say Hello");
        // 在同步方法内调用另一个同步方法
        seyHi();
    }
    // 定义一个同步方法（被另一个同步方法调用的同步方法）
    public synchronized void seyHi() {
        System.out.println(Thread.currentThread().getName() + " say Hi");
    }
}

public class ReentrantLockDemo {
    public static void main(String[] args) {
        ThreadDemo demo = new ThreadDemo();
        new Thread(() -> {
            demo.seyHello();
        },"T1").start();

        new Thread(() -> {
            demo.seyHello();
        },"T2").start();
    }
}

输出：
在这里插入图片描述

自旋锁

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

自旋锁的好处

循环比较获取直到成功为止，没有类似 wait 的阻塞

举例

package concurrency.day0411;

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

/**
 * @author Woo_home
 * @create by 2020/4/11  20:42
 */
public class CASDemo {

    // 原子引用线程
    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) {
        CASDemo casDemo = new CASDemo();

        new Thread(() -> {
            casDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            casDemo.myUnLock();
        },"A").start();

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

        new Thread(() -> {
            casDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            casDemo.myUnLock();
        },"B").start();
    }
}

输出：
在这里插入图片描述

独占锁（写锁）/共享锁（读锁）/互斥锁

  • 独占锁（写锁）：指的是该锁一次只能被一个线程所持有。对 ReentrantLock 和 synchronized 而言都是独占锁
  • 共享锁（读锁）：指的是该锁可被多个线程锁持有。对 ReentrantReadWriteLock 其读锁是共享锁，其写锁是独占锁。读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的

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

小总结：

  • 读 - 读能共存
  • 写 - 写不能共存

写操作：原子 + 独占，整个过程必须是一个完整的统一体，中间不许被分割，被打断

举例（未使用读写锁）

package concurrency.day0411;

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

/**
 * @author Woo_home
 * @create by 2020/4/12  12:39
 */

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

	// 写入操作
    public void put(String key, Object value) {
        System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key,value);
        System.out.println(Thread.currentThread().getName() + "\t 写入完成：" + key);
    }

	// 读取操作
    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "\t 正在读取：");
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Object result = map.get(key);
        System.out.println(Thread.currentThread().getName() + "\t 读取完成：" + result);
    }
}

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

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

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

输出：
在这里插入图片描述
可以发现打印乱七八糟的，一个线程还没写入完成另一个线程就跟着写入了

举例（使用读写锁）

package concurrency.day0411;

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

/**
 * @author Woo_home
 * @create by 2020/4/12  12:39
 */

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

	// 使用读写锁
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void put(String key, Object value) {
    	// 写之前加锁
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成：" + key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        	// 写完后解锁
            readWriteLock.writeLock().unlock();
        }

    }

    public void get(String key) {
    	// 读之前加锁
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在读取：");
            try {
                TimeUnit.MILLISECONDS.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 {
        	// 读完后解锁
            readWriteLock.readLock().unlock();
        }
    }
}

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

        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(tempInt+"",tempInt+"");
            },String.valueOf(i)).start();
        }

        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.get(tempInt+"");
            },String.valueOf(i)).start();
        }
    }
}

在这里插入图片描述

Woo_home
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈对java中锁的理解
08-31
本文主要讲述java中锁的相关知识。具有很好的参考价值，下面跟着小编一起来看下吧
深入理解java自旋锁
08-25
深入理解Java自旋锁 Java自旋锁是一种锁机制，用于解决多线程之间的变量同步问题。自旋锁的实现是基于CAS（Compare And Swap）算法的，它可以在不使用锁的情况下实现多线程之间的变量同步。 自旋锁的定义是指当一...
if null 锁 java_java中锁的理解
weixin_31155097的博客
02-13 244
在并发编程中，经常遇到多个线程访问同一个 共享资源 ，这时候作为开发者必须考虑如何维护数据一致性，在java中synchronized关键字被常用于维护数据一致性。synchronized机制是给共享资源上锁，只有拿到锁的线程才可以访问共享资源，这样就可以强制使得对共享资源的访问都是顺序的，因为对于共享资源属性访问是必要也是必须的，下文会有具体示例演示。一.java中的锁一般在java中所说的锁就...
java锁的理解
u014411730的博客
11-02 245
import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; /**  * 原子操作：不可被打断的一些列操作，32位多处理器主要通过对总线和缓存加锁保证原子性。  * 首先要保证原子性，需要处理器对于数据的处理要保证原子性，当一个处理器读取内
关于java锁的理解
maidangcai的博客
07-01 186
最近在学习java编程知识，在这里记录下关于sychornized的理解 1.sychornized对使用者透明，调用者并不知道JVM获取锁的流程及其种类。 2.默认加锁顺序为偏向锁、轻量级锁、重量级锁，偏向锁默默认2秒后自动开启，可通过XX：BiasedLockingStartupDelay=0禁用延迟，通过XX:- UseBiasedLocking=false关闭偏向锁。 4.sychornized可作用与代码块以及方法声明处，当作用于代码块，程序编译为字节码指令后对应monitorenter、m
彻底理解Java中的各种锁.pdf
06-18
通过以上对Java锁机制的详细介绍，可以看出Java在并发控制方面具有丰富的工具和策略，它们能够帮助开发者在多线程编程中处理好资源竞争和线程协作的问题，从而编写出高效且线程安全的应用程序。
Java锁之自旋锁详解
09-04
在设计和实现并发程序时，理解自旋锁的工作原理及其优缺点是非常关键的。Java提供了多种锁机制，如`synchronized`关键字和`ReentrantLock`，开发者可以根据实际需求灵活选择。在实际应用中，应充分考虑锁的公平性、...
Java中锁的理解
最新发布
scarehunter的博客
09-18 114
在计算机科学中，锁(lock)或互斥(mutex)是一种同步机制，用于在有许多执行线程的环境中强制对资源的访问限制。锁旨在强制实施互斥排他、并发控制策略。锁通常需要硬件支持才能有效实施。这种支持通常采取一个或多个原子指令的形式，如"test-and-set", "fetch-and-add" or "compare-and-swap"”。这些指令允许单个进程测试锁是否空闲，如果空闲，则通过单个原子操作获取锁。
理解Java中的锁
ywb201314的专栏
03-21 289
编者按，作为一个Java程序员，在面试时候，经常会被问到多线程，高并发相关的内容，及各种各样锁，如公平锁，乐观锁，可重入锁等，这篇文章就简单解释下以下常见的各种锁。 公平锁/非公平锁 可重入锁 独享锁/共享锁 互斥锁/读写锁 乐观锁/悲观锁 分段锁 偏向锁/轻量级锁/重量级锁 自旋锁 公平锁/...
关于java中的锁的理解
fct2001140269的博客
11-10 284
关于java中的锁的理解（通俗易懂） http://blog.csdn.net/u012291108/article/details/51348603 一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限，在Java里边就是拿到某个同步对象的锁（一个对象只有一把锁）； 如果这个时候同步对象的锁被其他线程拿走了，他（这个线程）就只能等了（线程阻塞在锁池等待队列中）。 取...
Java并发锁相关面试知识整理
noob9527的博客
05-30 295
java锁有悲观锁和乐观锁，乐观锁通过cas实现，悲观锁有ReentrantLock和synchronized。ReentrantLock特性：时间锁等候、可中断锁等候、无块结构锁、多个条件变量或者锁投票等。synchronized只有一个好处，使用方便简单，不用主动释放锁。ReentrantLock和synchronized都是可重入锁。 一、synchronized锁 1、锁升级 锁的4中...
Java中对锁的一些理解
weixin_43785783的博客
12-15 369
对锁的理解? 一 悲观锁:排它锁(独占锁,互斥锁),公平所,非公平锁,写锁(排它锁) 二 乐观锁:一般基于CAS算法:并发锁,读锁 对JUC包中一些Lock对象以及Lock工具类等对象的理解 一 CountDownLatck 是一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它能允许一个或多个线程一直等待 使用: package cgb.java.thread; import java....
深入理解JAVA中的锁（一）
java_lg的博客
12-02 377
深入理解JAVA中的锁 1. 锁的概念 自旋锁 ：是指当一个线程在获取锁的时候，如果锁已经被其他线程获取，那么该线程将循环等待，然后不断判断锁是否能够被成功获取，直到获取到锁才会退出循环。 例如：CAS在for循环的应用 乐观锁 ：假定没有冲突，在修改数据时如果发现数据和之前获取的不一致，则读最新数据，修改后重试修改。 例如：CAS 悲观锁 ：假定会发生并发冲突，同步所有对数据的相关操作，从读数据...
三、对java中锁的理解
wu1308156206的博客
07-09 156
对锁的理解
深入理解Java内存模型（五）——锁
怀素的专栏
06-04 691
锁的释放 - 获取建立的 happens before 关系 锁是 java 并发编程中最重要的同步机制。锁除了让临界区互斥执行外，还可以让释放锁的线程向获取同一个锁的线程发送消息。 下面是锁释放 - 获取的示例代码： class MonitorExample { int a = 0; public synchronized void writer() { //1 ...
java如何理解锁_深入理解 Java 中的锁
weixin_34298263的博客
02-27 345
并发编程时首先考虑的是线程安全问题，线程安全，指的是多线程访问下，某个函数被多个线程调用多次，都能够正确处理各个线程的局部变量，并且计算结果正确。解决线程安全问题，一般有三种方式：使用 ThreadLocal 避免线程共享变量使用 synchronized 和 lock 进行同步控制使用原子类声明变量锁用来做同步控制，可以控制多个线程访问共享资源的顺序，Java 中内置的锁 synchronize...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值