synchronized与Lock

已于 2024-01-05 14:11:49 修改
阅读量376 收藏 9
点赞数 10
分类专栏： Java基础 文章标签： java
于 2023-11-28 10:55:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pluto_CSND/article/details/134661064
版权

Java中解决公共变量访问的线程安全问题的主要的方法是加锁，包括synchronized、Lock

一、synchronized

1.1、synchronized 修饰目标

synchronized 可用于修饰方法（静态的、常规的）、代码块。其中，锁定代码块常用。

/**************************************************
 * synchronized 修饰静态方法（锁粒度太大，不常用）
 **************************************************/
public class Synchronized1 {

    //内部静态量
    private static int n = 0;

    //内部静态类
    private static class Counter{

        private static int MAX = 1000000;

        private synchronized static void increase() {
            for (int i = 0; i < MAX; i++) {
                n++;
            }
        }

        private synchronized static void decrease() {
            for (int i = 0; i < MAX; i++) {
                n--;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> { Counter.increase(); });
        thread1.start();

        Thread thread2 = new Thread(() -> { Counter.decrease(); });
        thread2.start();

        thread1.join();
        thread2.join();
        System.out.println(n);
    }
}

/************************************************
 * synchronized 修饰普通方法（锁粒度大，不常用）
 ************************************************/
public class Synchronized2 {

    //内部静态量
    private static int n = 0;

    //内部静态类
    private static class Counter{

        private static int MAX = 1000000;

        private synchronized void increase() {
            for (int i = 0; i < MAX; i++) {
                n++;
            }
        }

        private synchronized void decrease() {
            for (int i = 0; i < MAX; i++) {
                n--;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        Counter counter  = new Counter();
        Thread thread1 = new Thread(() -> { counter.increase(); });
        thread1.start();

        Thread thread2 = new Thread(() -> { counter.decrease(); });
        thread2.start();

        thread1.join();
        thread2.join();
        System.out.println(n);
    }
}

/*******************************************
 *     synchronized 修饰代码块（常用）
 *******************************************/
public class Synchronized3 {

    // 内部静态量
    private static int n = 0;

    // 内部静态类
    private static class Counter {

        private static int MAX = 1000000;

        private void increase() {
            for (int i = 0; i < MAX; i++) {
                //synchronized (锁载体)，方法里锁载体要一样
                synchronized (this) {
                    n++;
                }
            }
        }

        private void decrease() {
            for (int i = 0; i < MAX; i++) {
                //synchronized (锁载体)，方法里锁载体要一样
                synchronized (this){
                    n--;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> { counter.increase(); });
        thread1.start();

        Thread thread2 = new Thread(() -> { counter.decrease(); });
        thread2.start();

        thread1.join();
        thread2.join();
        System.out.println(n);
    }
}

1.2、synchronized 加锁对象（锁载体）

synchronized 的加锁对象可以是【类】、【this对象】、【自定义对象】。其中，自定义对象常用。对于同一个业务的多个线程的加锁对象，需是同一对象（即加同一把锁），否则加锁无效。

/*******************************************
 *   synchronized 加锁对象为类、this对象
 *******************************************/
public class Synchronz {

    // 内部静态量
    private static int n = 0;

    // 内部静态类
    private static class Counter {

        private static int MAX = 1000000;

        private void increase() {
            for (int i = 0; i < MAX; i++) {
                //synchronized (锁载体)，方法里锁载体要一样
                synchronized (this) {
                    n++;
                }
            }
        }

        private void decrease() {
            for (int i = 0; i < MAX; i++) {
                //synchronized (锁载体)，方法里锁载体要一样
                synchronized (Synchronz.class){
                    n--;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> { counter.increase(); });
        thread1.start();

        Thread thread2 = new Thread(() -> { counter.decrease(); });
        thread2.start();

        thread1.join();
        thread2.join();
        System.out.println(n);
    }
}

/*******************************************
 *     synchronized 加锁对象为自定义对象
 *******************************************/
public class Synchronz2 {

    // 内部静态量
    private static int n = 0;
    private static Object obj = new Object();

    // 内部静态类
    private static class Counter {

        private static int MAX = 1000000;

        private void increase() {
            for (int i = 0; i < MAX; i++) {
                //synchronized (锁载体)，方法里锁载体要一样
                synchronized (obj) {
                    n++;
                }
            }
        }

        private void decrease() {
            for (int i = 0; i < MAX; i++) {
                //synchronized (锁载体)，方法里锁载体要一样
                synchronized (obj){
                    n--;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> { counter.increase(); });
        thread1.start();

        Thread thread2 = new Thread(() -> { counter.decrease(); });
        thread2.start();

        thread1.join();
        thread2.join();
        System.out.println(n);
    }
}

1、synchronized是非公平锁（来的早不如来的巧），具有互斥性、排他性：线程执行到某个对象的 synchronized 时占用锁，其他线程如果也执行到同一对象 synchronized 发现锁占用，会自旋尝试获取锁一段时间，失败后进入休眠状态（排队）等待被操作系统唤醒。
2、synchronized 的锁信息存储在Java对象头里（隐藏属性）：Java对象有个隐藏的对象头，其中存储了当前锁的状态标识（占用or空闲），同时还存储了占用当前锁的线程ID；

1.3、synchronized 实现原理

①在代码层面：
synchronized加锁的对象里有一个的隐藏的对象头，这个对象头（可看作一个类）里有很多属性，其中比较关注的两个属性是：是否加锁的标识和占有当前锁的线程id。每次进⼊ synchronized 修饰的代码块时，会去对象头中先判断加锁的标识，再判断拥有当前锁的线程id，从而决定当前线程能否继续执行。
◆判断加锁标识为false，即对象头未加锁，当前线程可以进入synchronized 修饰的代码块，并设置加锁标识为true，设置拥有当前锁的线程id为此线程id。
◆判断加锁标识为true，即对象头已加锁，需进一步判断拥有当前锁的线程id是否为此线程id，若是，则继续往下执行（即可重入）；否则，不能往下执行，需要等待锁资源释放后重新竞争再获取锁。

②在JVM和操作系统层面：
synchronized同步锁是通过JVM内置的Monitor监视器实现的，而监视器又是依赖操作系统的互斥锁Mutex实现的。

二、Lock

/**
 * *.lock()要放到try外（官建）或try首行
 * *.unlock()要放在finally里，防止锁资源永久占用
 */
public class LockTest {

    private static int n = 0;

    private static class Counter{

        private static Lock lock = new ReentrantLock();
        private static int MAX = 1000000;

        private static void increase() {
            for (int i = 0; i < MAX; i++) {
                // 加锁
                lock.lock();
                try{
                    n++;
                } finally {
                    // 释放锁
                    lock.unlock();
                }
            }
        }

        private static void decr() {
            for (int i = 0; i < MAX; i++) {
                // 加锁
                lock.lock();
                try{
                    n--;
                } finally {
                    // 释放锁
                    lock.unlock();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> { Counter.increase(); });
        thread1.start();

        Thread thread2 = new Thread(() -> { Counter.decr(); });
        thread2.start();

        thread1.join();
        thread2.join();
        System.out.println(n);
    }
}
Pluto_CSND
关注
专栏目录
Synchronized与Lock
03-30
"Synchronized与Lock"这个主题探讨了两种主要的同步机制：synchronized关键字和Lock接口（包括其实现类如ReentrantLock）。这两种机制都用于实现线程间的互斥访问，但它们在功能、灵活性和性能上有所差异。 首先，...
Synchronized 和 Lock 的区别和使用场景
01-20
本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...
Synchronized与Lock区别
小萌新的博客
02-24 5598
文章目录1、具体区别(核心)2、在锁概念上的区别3、性能比较 1、具体区别(核心) (1)synchronized和Lock都是可重入锁,前者是jvm中使用monitorenter(1个)和monitorexit(2个)来 实现同步且其中阻塞和唤醒是wait和notify,后者是juc包中的lock层次使用,依赖于AQS来实现加锁和解锁; (2)synchronized是非公平锁,ReentrantLock可以设置公平锁或者非公平锁; (3)synchronized是不可中断且无法获取锁状态,后者是可中断l
synchronized与Lock使用哪个
Wengzhengcun的博客
02-21 277
只有当synchronized无法满足需求时，才需要使用Lock，否则，一律使用synchronized。 使用Lock的场景：可定时的、可轮询的、可中断的锁获取操作，公平队列（synchronized只实现了非公平锁），非块结构的锁。 内置锁与ReentrantLock相比还有另一个优点：在线程转储（使用jstack）中能给出在哪些调用帧中获得了哪些锁，并能检测和识别发生死锁的线程。JVM并...
synchronized与Lock的区别
qq_34287953的博客
07-15 167
synchronized与Lock的区别 1、锁的实现方式不同：synchronized采用monitor enter/monitor exite实现；Lock采用CAS实现。 2、锁的释放方式不同：synchronized自动释放锁；Lock需要手动释放。 3、synchronized是java关键字；Lock是java的API。 4、synchronized不可以中断；Lock可以中断（lockInterruptibly()方法）。 5、synchronized是非公平锁；Lock可是是非公平锁和公平锁
synchronized与Lock底层原理
wuliyouMaozhi的博客
09-25 1104
System.out.println("我是果橙呀");}}}阻塞模式抢占锁的方法。如果当前线程抢占锁成功，则继续向下执行程序的业务逻辑，否则，当前线程会阻塞，直到其它抢占到锁的线程释放锁后再继续抢占锁。可中断模式抢占锁的方法。当前线程在调用lockInterruptibly()方法抢占锁的过程中，能够响应中断信号，从而能够中断当前线程。非阻塞模式下抢占锁的方法。当前线程调用tryLock()方法抢占锁时，线程不会阻塞，而会立即返回抢占锁的结果。
Synchronized与lock锁区别
热门推荐
xc_blog
09-02 1万+
1、synchronized是java关键字，他是jvm层面； lock是接口（相应的实现比如ReentrantLock)； 2、synchronized无法获取到锁的状态， lock可以获取到锁的状态； 3、synchronized是自动锁，如果代码执行完毕或发生异常， 他会自动释放锁的资源， lock手动锁，需要人工进行调用unlock方法进行释放锁的资源， 一般都是放在finally； 如果不释放会发生死锁； 4、synchronized如果线程a获取到锁的资源，发生阻塞，线程b会一直等待， 而
Java--Synchronized与Lock的区别及底层实现
MinggeQingchun的博客
02-09 650
起初 Java中只有 synchronized 这一种对程序加锁的方式，因此在JDK1.5之前，我们在编写并发程序的时候无一例外都是使用synchronized来实现线程同步的，而synchronized在JDK1.5之前同步的开销较大效率较低，因此在JDK1.5之后，推出了代码层面的Lock接口（synchronized为jvm层面）来实现与synchronized同样功能的同步锁，并且针对不同的并发场景也加入了许多个性锁功能 一、synchronized synchronized是Java中的一个.
synchronized与Lock的区别与使用
我的书包哪里去了
08-12 1311
目录 四种锁的介绍 synchronized的缺点 synchronized和Lock的区别 Lock接口 Lock实现类ReentrantLock ReadWriteLock接口 ReadWriteLock实现类ReentrantReadWriteLock 四种锁的介绍 ...
synchronized 与 Lock 的区别
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
08-06 8169
在Java多线程编程中，`synchronized`和`Lock`都扮演着确保线程安全访问共享资源的重要角色，但它们之间存在一些关键的区别。
Synchronized与Lock对比分析
itbird的专栏
03-29 262
Synchronized与Lock对比分析 1.Lock是接口，Synchronized是关键字 2.Synchronized可以锁对象、锁方法、锁代码块，Lock只能锁代码块 3.Synchronized锁不需要主动释放，Lock需要在finally中主动释放 4.Synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可） 5.Synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁 ...
面试经典问题系列:Synchronized与Lock的区别
m0_50672338的博客
02-22 255
如果面试官问你Synchronized与Lock的区别的时候,可以按照一下几条回答.显得更加具有条理性
Java编程synchronized与lock的区别【推荐】
08-29
Java 编程 synchronized 与 Lock 的区别 synchronized 和 Lock 是 Java 编程中两种常用的同步机制，用于实现线程安全的访问。两者都可以实现同步访问，但是它们有着不同的设计理念和使用场景。 synchronized 的...
Java-网络
2301_81543552的博客
09-14 708
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 644
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 292
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1153
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
记录开发一个英语听力训练网站
业余程序员Blue的博客
09-14 708
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
最新发布
m0_66572126的博客
09-14 683
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
Java编程：synchronized与Lock深度解析与比较
Java编程中的synchronized与lock是两种不同的线程同步机制，它们在处理并发问题时有着各自的优缺点。synchronized是Java语言内置的关键字，主要用于同步控制，当一个代码块被synchronized修饰后，同一时间只有一个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值