Java:使用synchronized和Lock对象获取对象锁

最新推荐文章于 2023-12-16 22:43:05 发布
最新推荐文章于 2023-12-16 22:43:05 发布
阅读量528 收藏
点赞数
分类专栏： 多线程
原创作品，允许转载，转载时请务必以超链接形式标明文章  原始出处 、作者信息和本声明。否则将追究法律责任。 http://zhangjunhd.blog.51cto.com/113473/70300
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。
1.对象的锁
所有对象都自动含有单一的锁。
JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。
只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。
每当任务离开一个synchronized方法，计数递减，当计数为0的时候，锁被完全释放，此时别的任务就可以使用此资源。
2.synchronized同步块
2.1同步到单一对象锁
当使用同步块时，如果方法下的同步块都同步到一个对象上的锁，则所有的任务（线程）只能互斥的进入这些同步块。
Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，虽然这些同步块处在不同的方法中，但由于是同步到同一个对象（当前对象  synchronized  ( this )），所以对它们的方法依然是互斥的。
Resource1.java
package com.zj.lock;
import java.util.concurrent.TimeUnit;
 
public class Resource2 {
     private Object  syncObject1 =  new Object();
     private Object  syncObject2 =  new Object();
 
     public void f() {
        // other operations should not be locked...
       System. out.println(Thread. currentThread().getName()
              +  ":not synchronized in f()");
        synchronized ( this) {
            for ( int i = 0; i < 5; i++) {
              System. out.println(Thread. currentThread().getName()
                     +  ":synchronized in f()");
               try {
                  TimeUnit. SECONDS.sleep(3);
              }  catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
     public void g() {
        // other operations should not be locked...
       System. out.println(Thread. currentThread().getName()
              +  ":not synchronized in g()");
        synchronized ( syncObject1) {
            for ( int i = 0; i < 5; i++) {
              System. out.println(Thread. currentThread().getName()
                     +  ":synchronized in g()");
               try {
                  TimeUnit. SECONDS.sleep(3);
              }  catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
     public void h() {
        // other operations should not be locked...
       System. out.println(Thread. currentThread().getName()
              +  ":not synchronized in h()");
        synchronized ( syncObject2) {
            for ( int i = 0; i < 5; i++) {
              System. out.println(Thread. currentThread().getName()
                     +  ":synchronized in h()");
               try {
                  TimeUnit. SECONDS.sleep(3);
              }  catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
     public static void main(String[] args) {
        final Resource2 rs =  new Resource2();
 
        new Thread() {
            public void run() {
              rs.f();
           }
       }.start();
 
        new Thread() {
            public void run() {
              rs.g();
           }
       }.start();
 
       rs.h();
    }
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
main:synchronized in h()
Thread-1:not synchronized in g()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
3.Lock对象锁
除了使用synchronized外，还可以使用Lock对象来创建临界区。Resource3.java的演示效果同Resource1.java；Resource4.java的演示效果同Resource2.java。
Resource3.java
package com.zj.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class Resource4 {
     private Lock  lock1 =  new ReentrantLock();
     private Lock  lock2 =  new ReentrantLock();
     private Lock  lock3 =  new ReentrantLock();
 
     public void f() {
        // other operations should not be locked...
       System. out.println(Thread. currentThread().getName()
              +  ":not synchronized in f()");
        lock1.lock();
        try {
            for ( int i = 0; i < 5; i++) {
              System. out.println(Thread. currentThread().getName()
                     +  ":synchronized in f()");
               try {
                  TimeUnit. SECONDS.sleep(3);
              }  catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }  finally {
            lock1.unlock();
       }
    }
 
     public void g() {
        // other operations should not be locked...
       System. out.println(Thread. currentThread().getName()
              +  ":not synchronized in g()");
        lock2.lock();
        try {
            for ( int i = 0; i < 5; i++) {
              System. out.println(Thread. currentThread().getName()
                     +  ":synchronized in g()");
               try {
                  TimeUnit. SECONDS.sleep(3);
              }  catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }  finally {
            lock2.unlock();
       }
    }
 
     public void h() {
        // other operations should not be locked...
       System. out.println(Thread. currentThread().getName()
              +  ":not synchronized in h()");
        lock3.lock();
        try {
            for ( int i = 0; i < 5; i++) {
              System. out.println(Thread. currentThread().getName()
                     +  ":synchronized in h()");
               try {
                  TimeUnit. SECONDS.sleep(3);
              }  catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }  finally {
            lock3.unlock();
       }
    }
 
     public static void main(String[] args) {
        final Resource4 rs =  new Resource4();
 
        new Thread() {
            public void run() {
              rs.f();
           }
       }.start();
 
        new Thread() {
            public void run() {
              rs.g();
           }
       }.start();
 
       rs.h();
    }
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
main:synchronized in h()
Thread-1:not synchronized in g()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Jmark_GC
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程3 —— 对象锁和类锁
扎瓦菜鸟
09-11 462
synchronized关键字作用在同步代码块上，给共享变量“上锁”可以解决线程安全问题。这把“锁”可以作用在某个对象上，也可以作用在某个类上。 举个栗子，有个自助银行，里面有两台ATM机，工作人员可以看到每次存取款之后机器里钞票的总金额数。现在有两个人来存钱，各存50元。 没有锁 在下面的代码中，两个线程t1、t2相当于两个人，每个Service对象相当于一台ATM机。这里先只创建了一个S...
Java对象锁和类锁全面解析（多线程synchronize
11-22
Java对象锁和类锁是Java多线程编程中至关重要的概念，它们是通过`synchronized`关键字来实现的，用于确保代码在并发环境下的线程安全。在这个全面解析中，我们将深入探讨这两个锁机制，理解它们的工作原理以及如何在...
使用synchronized和Lock对象获取对象锁
阿O、不拽
09-16 183
 Java:使用synchronized和Lock对象获取对象锁     下面使用ReentrantLock这个锁来实现加锁功能：     package com.tch.test.concurrent; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; ...
java 对象 lock_Java:使用synchronized和Lock对象获取对象锁
weixin_36073714的博客
02-15 255
3.Lock对象锁除了使用synchronized外，还可以使用Lock对象来创建临界区。Resource3.java的演示效果同Resource1.java；Resource4.java的演示效果同Resource2.java。Resource3.javapackage com.zj.lock;import java.util.concurrent.TimeUnit;import java.ut...
Synchronized 和 Lock 的区别和使用场景
01-20
3. 锁住整个对象：当`synchronized`后面跟的是`this`或者类实例时，锁住的是整个对象，不允许其他线程同时访问对象的所有`synchronized`方法和代码块。 二、Lock接口 Lock接口提供了更灵活的锁控制，比`...
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例
08-28
* Lock对象是Java中的一个锁机制，提供了比synchronized方法和语句更好的性能和灵活性。 * Lock对象可以用来解决线程同步问题，提供了比synchronized方法和语句更好的性能和灵活性。 * 在使用Lock对象时，需要注意锁...
Java synchronized关键字和Lock接口实现原理
08-25
Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。...
深入Synchronized和java.util.concurrent.locks.Lock的区别详解
09-05
而Lock接口，它是Java并发包（java.util.concurrent.locks）的一部分，提供了比synchronized更高级和灵活的锁操作。Lock接口的实现类，如ReentrantLock，提供了尝试获取锁、可中断的锁等待、定时锁等待等功能。使用...
Android多线程之同步锁的使用
08-29
本篇文章主要介绍了Android多线程之同步锁的使用，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
synchronized获取对象锁
wanglu2003132的博客
12-28 428
synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要显式指定某个方法为synchronized. 1. [code="java"] Public synchronized void methodAAA() 　　{ 　　//…. 　　} [/c...
从头认识java-17.4 详解同步（3）-对象锁
raylee2007的专栏
01-11 1742
这一章节我们接着上一章节的问题，给出一个解决方案：对象锁。1.什么是对象锁？对象锁是指Java为临界区synchronized(Object)语句指定的对象进行加锁，对象锁是独占排他锁。2.什么是临界区？临界区是指程序中的一个代码段，在这段代码中，单独并发的线程对同一个对象进行访问。在Java中，用关键字“synchronized”标识一个临界区。3.常用的对象锁：synchronized和Ree
《Kotlin核心编程》笔记：反射、注解和加锁
最新发布
川峰的博客
12-16 572
通过上面的运行结果我们发现，对于属性和无参数的函数，它们都有一个隐藏的参数为类的实例，而对于声明参数的函数，类的实例作为第 1 个参数，而声明的参数作为后续的参数。由于 Kotlin 兼容 Java，所以所有 Java 可以添加注解的地方，Kotlin 也都可以。通过上面对比我们发现，Kotlin 和 Java 注解整体上是保持一致的，熟悉 Java 注解的读者应该很容易将这部分知识迁移到 Kotlin。顾名思义就是目标对象，也就是我们定义的注解能够应用于哪些目标对象，可以同时指定多个作用的目标对象。
Java中的Lock详解
热门推荐
向上的"狼"的博客
04-28 2万+
简介 java.util.concurrent.locks.Lock 是一个类似于synchronized 块的线程同步机制。但是 Lock比 synchronized 块更加灵活。Lock是个接口，有个实现类是ReentrantLock。 Lock和syncronized的区别
你刚才提到获取对象的锁，这个“锁”到底是什么？如何确定对象的锁？
qq_62205007的博客
12-30 746
锁”的本质其实是 monitorenter 和 monitorexit 字节码指令的一个 Reference 类型的参数，即要锁定和解锁的对象。我们知道，使用 Synchronized 可以修饰不同的对象，因此，对应的对象锁可以这么确定。 1. 如果 Synchronized 明确指定了锁对象，比如 Synchronized（变量名）、Synchronized(this) 等，说明加解锁对象为该对象。 2. 如果没有明确指定： 若 Synchronized 修饰的方法为非静态方法，表示此方法对应的对象为
java锁synchronized与lock
06-28
Java中的锁机制有两种：synchronized和Lock。 synchronized是Java中最基本的锁机制，它是Java中的内置锁，可以用于同步方法和同步代码块。synchronized锁机制是基于对象的，每个对象都有一个锁，当一个线程访问一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值