Java内置锁的简单认识

最新推荐文章于 2024-11-15 18:38:47 发布
最新推荐文章于 2024-11-15 18:38:47 发布
阅读量108 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/xyhuangjinfu/p/6505329.html
版权

        多线程开发离不开锁机制，现在的Java语言中，提供了2种锁，一种是语言特性提供的内置锁，还有一种是 java.util.concurrent.locks 包中的锁，这篇文章简单整理一下内置锁的知识点。

 

内置锁在Java语言中的表现：

        多线程的锁，其实本质上就是给一块内存空间的访问添加访问权限，因为Java中是没有办法直接对某一块内存进行操作的，又因为Java是面向对象的语言，一切皆对象，所以具体的表现就是某一个对象承担锁的功能，每一个对象都可以是一个锁。内置锁，使用方式就是使用 synchronized 关键字，synchronized 方法或者 synchronized 代码块。

 

每一种 synchronized 写法的锁是哪个对象：

 

1、指定当前对象加锁：

    private synchronized void function() {
        //TODO execute something
    }

 

2、指定当前类的Class对象加锁：

    private static synchronized void function() {
        //TODO execute something
    }


注意此处的 static 关键字。 

3、指定任意对象加锁：

private void function() {
    synchronized (object) {
        //TODO execute something
    }
}


此时，这段同步代码块的锁加在object对象上面。该对象可以是当前对象（object == this），也可以是当前类的Class对象（object == MyClass.class）。

 

简单验证一下：

现有如下的类：

public class SynchronizedTest {
    private Object lock = new Object();

    public void synchronizedBlockOnObject(long executeTime) {
        synchronized (lock) {
            System.out.println(Thread.currentThread().getName() + " -> start synchronizedBlockOnObject");
            doSomething(executeTime);
            System.out.println(Thread.currentThread().getName() + " -> end synchronizedBlockOnObject");
        }
    }

    public void synchronizedBlockOnThis(long executeTime) {
        synchronized (this) {
            System.out.println(Thread.currentThread().getName() + " -> start synchronizedBlockOnThis");
            doSomething(executeTime);
            System.out.println(Thread.currentThread().getName() + " -> end synchronizedBlockOnThis");
        }
    }

    public void synchronizedBlockOnClass(long executeTime) {
        synchronized (SynchronizedTest.class) {
            System.out.println(Thread.currentThread().getName() + " -> start synchronizedBlockOnClass");
            doSomething(executeTime);
            System.out.println(Thread.currentThread().getName() + " -> end synchronizedBlockOnClass");
        }
    }

    public synchronized void synchronizedMethodOnThis(long executeTime) {
        System.out.println(Thread.currentThread().getName() + " -> start synchronizedMethodOnThis");
        doSomething(executeTime);
        System.out.println(Thread.currentThread().getName() + " -> end synchronizedMethodOnThis");
    }

    public static synchronized void synchronizedMethodOnClass(long executeTime) {
        System.out.println(Thread.currentThread().getName() + " -> start synchronizedMethodOnClass");
        doSomething(executeTime);
        System.out.println(Thread.currentThread().getName() + " -> end synchronizedMethodOnClass");
    }

    private static void doSomething(long executeTime) {
        try {
            Thread.sleep(executeTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


 

 

1、static synchronized 方法 和 synchronized (MyClass.class) {} 同步代码块的锁都加在 MyClass.class 对象上面：

public static void main(String[] args) {
        SynchronizedTest synchronizedTest = new SynchronizedTest();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                SynchronizedTest.synchronizedMethodOnClass(3000);
            }
        }, "Thread static synchronized method").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedTest.synchronizedBlockOnClass(2000);
            }
        }, "Thread synchronized block on Class").start();
    }


运行结果如下：

Thread static synchronized method -> start synchronizedMethodOnClass
Thread static synchronized method -> end synchronizedMethodOnClass
Thread synchronized block on Class -> start synchronizedBlockOnClass
Thread synchronized block on Class -> end synchronizedBlockOnClass


说明当线程 Thread static synchronized method 进入方法 synchronizedMethodOnClass 的时候，线程Thread synchronized block on Class 是不能进入synchronizedBlockOnClass 代码块的。

 

2、非 static 的 synchronized 方法和 synchronized (this) {} 同步代码块的锁都加在当前对象上面：

public static void main(String[] args) {
    SynchronizedTest synchronizedTest = new SynchronizedTest();

    new Thread(new Runnable() {
        @Override
        public void run() {
            synchronizedTest.synchronizedMethodOnThis(3000);
        }
    }, "Thread non-static synchronized method").start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            synchronizedTest.synchronizedBlockOnThis(2000);
        }
    }, "Thread synchronized block on this").start();
}



运行结果如下：

Thread non-static synchronized method -> start synchronizedMethodOnThis
Thread non-static synchronized method -> end synchronizedMethodOnThis
Thread synchronized block on this -> start synchronizedBlockOnThis
Thread synchronized block on this -> end synchronizedBlockOnThis


说明当线程 Thread non-static synchronized method 进入方法 synchronizedMethodOnThis 的时候，线程Thread synchronized block on this 是不能进入synchronizedBlockOnThis 代码块的。

 

3、当锁加在 MyClass.class 、 this 、 任意对象，这三种情况，起不到任何同步作用：

    public static void main(String[] args) {
        SynchronizedTest synchronizedTest = new SynchronizedTest();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedTest.synchronizedMethodOnThis(3000);
            }
        }, "Thread non-static synchronized method").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                SynchronizedTest.synchronizedMethodOnClass(2000);
            }
        }, "Thread static sybchronized method").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedTest.synchronizedBlockOnObject(4000);
            }
        }, "Thread sybchronized block on other Object").start();
    }


运行结果如下：

Thread non-static synchronized method -> start synchronizedMethodOnThis
Thread static sybchronized method -> start synchronizedMethodOnClass
Thread sybchronized block on other Object -> start synchronizedBlockOnObject
Thread static sybchronized method -> end synchronizedMethodOnClass
Thread non-static synchronized method -> end synchronizedMethodOnThis
Thread sybchronized block on other Object -> end synchronizedBlockOnObject


说明当锁没有加在同一个对象上的时候，起不到线程间的同步作用。

 

 

Object中对内置锁进行操作的一些方法：

wait()系列：

wait()系列方法的作用是：使当前已经获得该对象锁的线程进入等待状态，并且释放该对象的锁。

notify()系列：

notify()系列方法的作用是：唤醒那些正在等待该对象锁的线程，使其继续运行。

 

基于wait() notify()机制，我们可以实现一个简易的生产者-消费者模型。

大体思路如下，一个生产者线程负责向一个仓库中存放（put）物品，一个消费者线程负责从仓库中取出（get）物品。

代码如下：

public class Warehouse {

    private Queue<Integer> queue;
    private int capacity;

    public Warehouse(int capacity) {
        this.capacity = capacity;
        queue = new LinkedList();
    }

    public synchronized void put(int num) {
        if (queue.size() >= capacity) {
            try {
                System.out.println(Thread.currentThread().getName() + " , put full wait");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        queue.add(num);
        System.out.println(Thread.currentThread().getName() + " , put : " + num + "  , queue -> " + queue);
        notifyAll();
    }

    public synchronized int get() {
        if (queue.isEmpty()) {
            try {
                System.out.println(Thread.currentThread().getName() + " , get empty wait");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        int num = queue.poll();
        System.out.println(Thread.currentThread().getName() + " , get : " + num + "  , queue -> " + queue);
        notifyAll();
        return num;
    }
}

 

    public static void main(String[] args) {
        Warehouse warehouse = new Warehouse(4);
        Random random = new Random();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    warehouse.put(random.nextInt(10));
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "生产者-01").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    warehouse.get();
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "消费者-01").start();
    }


运行结果如下：

生产者-01 , put : 5  , queue -> [5]
消费者-01 , get : 5  , queue -> []
生产者-01 , put : 7  , queue -> [7]
消费者-01 , get : 7  , queue -> []
生产者-01 , put : 9  , queue -> [9]
生产者-01 , put : 7  , queue -> [9, 7]
消费者-01 , get : 9  , queue -> [7]
生产者-01 , put : 0  , queue -> [7, 0]
生产者-01 , put : 5  , queue -> [7, 0, 5]
消费者-01 , get : 7  , queue -> [0, 5]
生产者-01 , put : 9  , queue -> [0, 5, 9]
生产者-01 , put : 6  , queue -> [0, 5, 9, 6]
消费者-01 , get : 0  , queue -> [5, 9, 6]
生产者-01 , put : 4  , queue -> [5, 9, 6, 4]
生产者-01 , put full wait
消费者-01 , get : 5  , queue -> [9, 6, 4]
生产者-01 , put : 6  , queue -> [9, 6, 4, 6]
生产者-01 , put full wait
消费者-01 , get : 9  , queue -> [6, 4, 6]
生产者-01 , put : 2  , queue -> [6, 4, 6, 2]
生产者-01 , put full wait
消费者-01 , get : 6  , queue -> [4, 6, 2]
生产者-01 , put : 9  , queue -> [4, 6, 2, 9]
生产者-01 , put full wait
消费者-01 , get : 4  , queue -> [6, 2, 9]
生产者-01 , put : 7  , queue -> [6, 2, 9, 7]
生产者-01 , put full wait
消费者-01 , get : 6  , queue -> [2, 9, 7]
生产者-01 , put : 2  , queue -> [2, 9, 7, 2]


 

转载于:https://www.cnblogs.com/xyhuangjinfu/p/6505329.html

antuo0634
关注
不得不知道的Java锁
天亮了的博客
01-14 313
1.Java主流锁的整体认知 话不多说，直接上图，先对Java主流锁有一个整体的认知 2.乐观锁悲观锁概念 悲观锁与乐观锁是一种广义概念，体现的是看待线程同步的不同角度 2.1乐观锁 定义：乐观锁认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据 锁实现：CAS算法，例如AtomicInteger类的原子自增是通过CAS自旋实现...
Java锁详解：“独享锁/共享锁+公平锁/非公平锁+乐观锁/悲观锁+线程锁”
m0_73257876的博客
08-19 348
在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好。在资源竞争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍，而ReentrantLock确还能维持常态。高并发量情况下使用ReentrantLock。和上面的类似，不激烈情况下，性能比synchronized略逊，而激烈的时候，也能维持常态。
java 内置锁_Java内置锁的简单认识
weixin_34593328的博客
02-12 195
多线程开发离不开锁机制，现在的Java语言中，提供了2种锁，一种是语言特性提供的内置锁，还有一种是 java.util.concurrent.locks 包中的锁，这篇文章简单整理一下内置锁的知识点。内置锁在Java语言中的表现：多线程的锁，其实本质上就是给一块内存空间的访问添加访问权限，因为Java中是没有办法直接对某一块内存进行操作的，又因为Java是面向对象的语言，一切皆对象，所以具体的表现...
java内置锁的简单认识
weixin_40482816的博客
06-18 331
多线程开发离不开锁机制，现在的Java语言中，提供了2种锁，一种是语言特性提供的内置锁，还有一种是 java.util.concurrent.locks 包中的锁，这篇文章简单整理一下内置锁的知识点。 1、内置锁在Java语言中的表现： 多线程的锁，其实本质上就是给一块内存空间的访问添加访问权限，因为Java中是没有办法直接对某一块内存进行操作的，又因为Java是面向对象的语言，一切皆对象，所以具体的表现就是某一个对象承担锁的功能，每一个对象都可以是一个锁。 内置锁，使用方式就是使用 ...
Java：java学习笔记之锁机制的简单理解和使用
JMW1407的博客
01-17 1607
锁机制的简单理解和使用锁机制参考 锁机制 参考 1、Java线程安全与锁机制 2、不可不说的Java“锁”事
锁的艺术：Java并发中的常用锁策略与实践
热门推荐
张彦峰的博客
05-12 166万+
对java锁相关内容进行整理分析：乐观锁 VS 悲观锁+自旋锁 VS 适应性自旋锁+无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁+公平锁 VS 非公平锁+可重入锁 VS 非可重入锁+独享锁 VS 共享锁
java如何使用线程锁的_Java线程知识：二、锁的简单使用
weixin_39646658的博客
02-25 277
锁的初步认识说到锁，相信大家都不陌生，这是我们生活中非常常见的一种东西，它的形状也各式各样。在生活中，我们通常用锁来锁住房子的大门、装宠物的笼子、装衣服的衣柜、以及装着我们一些小秘密的小抽屉......那么相同的，Java中的锁也各式各样，我们往往按照是否含有某一特性来定义锁，并将锁进行归、分组，具体可分为以下几种：而这些锁在Java中的具体实现都离不开synchronized 关键字和java....
JDK内置锁深入探究
Java知识图谱的博客
04-20 633
一、序言 本文讲述仅针对 JVM 层次的内置锁，不涉及分布式锁。 锁有多种分类形式，比如公平锁与非公平锁、可重入锁与非重入锁、独享锁与共享锁、乐观锁与悲观锁、互斥锁与读写锁、自旋锁、分段锁和偏向锁/轻量级锁/重量级锁。 下面将配合示例讲解各种锁的概念，期望能够达到如下目标：一是在生产环境中不错误的使用锁；二是在生产环境中选择恰当的锁。 对锁了解不多的情况下，应该首先保证业务的正确性，然后考虑性能，比如万金油synchronized锁或者自带多重属性的ReentrantReadWriteLock锁。不因并发导
【Java进阶】synchronized底层如何实现？什么是锁的升级、降级？
兴趣是最好的老师
07-15 826
全面分析了 synchronized 相关实现和内部运行机制，简单介绍了并发包中提供的其他显式锁，并结合样例代码介绍了其使用方法，希望对你有所帮助。
显式锁Lock和内置锁知识整理
发现问题，面对问题，分析问题，解决问题，总结问题
09-25 1388
文章目录（一）基础认识（1）synchronized内置锁的不足之处（2）锁的几种分类1. 可重入锁和非可重入锁2. 公平锁与非公平锁3. 读写锁和排它锁（二）Lock（1）ReentrantLock（2）轮询锁与定时锁（3）可中断的锁获取操作（4）非块结构的加锁（5）ReentrantReadWriteLock（6）Condition的使用以及和Object的监视器比较（7）synchronized和ReentrantLock的选择参考 （一）基础认识 （1）synchronized内置锁的不足之处 【1
Java中高级面试题总览(一)
击水三千里的专栏
03-29 2万+
高频面试题深入剖析
Java 全栈知识体系（ PDF 可下载）
m0_67698950的博客
03-17 5516
40000 +字长文总结，民工哥已将此文整理成PDF文档了，需要的见文后下载获取方式。 全栈知识体系总览 Java入门与进阶 面向对象与Java基础 Java 基础 - 面向对象 Java 基础 - 知识点 Java 基础 - 图谱 & Q/A 基础知识点复习完了以后，我们需要深入的理解Java中的一些基础机制： Java 基础 - 泛型机制详解 Java泛型这个特性是从JDK 1.5才开始加入的，因此为了兼容之前的版本
Java基础大纲
haifeng的博客
11-07 1059
Java基础梳理，大致内容，常常回顾，避免忘记
Java 全栈知识体系
weixin_70730532的博客
07-27 6989
40000 +字长文总结。 面向对象与Java基础 Java 基础 - 面向对象Java 基础 - 知识点Java 基础 - 图谱 & Q/A基础知识点复习完了以后，我们需要深入的理解Java中的一些基础机制：Java 基础 - 泛型机制详解Java泛型这个特性是从JDK 1.5才开始加入的，因此为了兼容之前的版本，Java泛型的实现采取了“伪泛型”的策略，即Java在语法上支持泛型，但是在编译阶段会进行所谓的“类型擦除”（Type Erasure），将所有的泛型表示（尖括号中的内容）都替换为具体的
Mybatis
最新发布
庸不易的博客
11-15 788
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
1112--接口
kequanrrr的博客
11-12 454
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 926
Rest请求处理
java加锁问题详解
qq_74056922的博客
11-14 762
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
什么是面向对象编程？什么是面向过程编程？
m0_70208894的博客
11-15 513
不同的编程范式适用于不同的场景，选择合适的范式可以提高代码的可维护性、可读性和效率。Java 和 Go 的选择反映了不同的设计哲学，Java 更加注重封装和对象的使用，而 Go 更加简洁，强调过程和函数的使用。
Java并发锁：悲观锁synchronized与乐观锁CAS的剖析
本文主要介绍了Java并发编程中的两种锁机制——悲观锁和乐观锁，以及它们各自的特点和应用场景。悲观锁以synchronized关键字为代表，而乐观锁则主要依赖于CAS（CompareAndSwap）操作。 ## 悲观锁 悲观锁是一种保守...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值