java 对象锁

最新推荐文章于 2023-06-21 16:41:40 发布
最新推荐文章于 2023-06-21 16:41:40 发布
阅读量322 收藏
点赞数
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。
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  Resource1 {
     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  ( this ) {
            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  ( this ) {
            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  Resource1 rs =  new  Resource1();
 
        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()
Thread-1:not synchronized in g()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
2.2 同步到多个对象锁
Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，这些同步块处在不同的方法中，并且是同步到三个不同的对象（ synchronized  ( this ) ， synchronized ( syncObject1 ) ， synchronized  ( syncObject2 )），所以对它们的方法中的临界资源访问是独立的。
Resource2.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  Resource3 {
     private  Lock  lock  =  new  ReentrantLock();
 
     public   void  f() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in f()" );
        lock .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  {
            lock .unlock();
       }
    }
 
     public   void  g() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in g()" );
        lock .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  {
            lock .unlock();
       }
    }
 
     public   void  h() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in h()" );
        lock .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  {
            lock .unlock();
       }
    }
 
     public   static   void  main(String[] args) {
        final  Resource3 rs =  new  Resource3();
 
        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()
Thread-1:not synchronized in g()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Resource4.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()



synchronized和lock的区别:

Lock 的锁定是通过代码实现的，而 synchronized 是在 JVM 层面上实现的
synchronized 在锁定时如果方法块抛出异常，JVM 会自动将锁释放掉，不会因为出了异常没有释放锁造成线程死锁。但是 Lock 的话就享受不到 JVM 带来自动的功能，出现异常时必须在 finally 将锁释放掉，否则将会引起死锁。

在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好，不管用没用过5.0多线程包的程序员都能理解。 

ReentrantLock: 
ReentrantLock提供了多样化的同步，比如有时间限制的同步，可以被Interrupt的同步（synchronized的同步是不能Interrupt的）等。在资源竞争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍。而ReentrantLock确还能维持常态。 

Atomic: 
和上面的类似，不激烈情况下，性能比synchronized略逊，而激烈的时候，也能维持常态。激烈的时候，Atomic的性能会优于ReentrantLock一倍左右。但是其有一个缺点，就是只能同步一个值，一段代码中只能出现一个Atomic的变量，多于一个同步无效。因为他不能在多个Atomic之间同步。 
大龙拳
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java对象锁
12-22
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。 　1.对象的锁 　所有对象都自动含有单一的锁。 　JVM负责跟踪对象被加锁的次数。... 　2.1同步到单一对象锁 　当使用同步块时，如果方法下的同步块
java多线程并发控制之锁
薛宇凡robin
11-19 6707
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。 1.对象的锁 所有对象都自动含有单一的锁。 JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。 只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。 每当任务离开一个synchronized方法，计数
Java并发控制 学习笔记1
又菜又爱玩
04-11 935
正常的锁当一个线程拿不到共享资源时，会把该线程阻塞，等共享资源释放后，再唤醒该阻塞线程并进行调度；自旋锁当一个线程拿不到共享资源时，它就一直while循环来询问该资源释放了没有，会一直占用cpu资源。如果大多事务的执行时间很短，自旋锁空转一会就能拿到资源，就用自旋锁，这时如果采用阻塞/唤醒思路的话，调度的时间消耗会比较大。flag = 0;= 1);flag = 2;= 2);flag = 0;
详解Java锁对象
Krive~Irving
06-21 2689
synchronized特性,锁对象,volatile,
JAVA线程并发数量控制_Java并发程序设计(6)线程池之线程数量的控制
weixin_31865445的博客
02-17 644
Java并发程序设计(6)线程池之线程数量的控制1.1.ExecutorServiceExecutorService 是线程池的接口。Executors 是用于创建不同线程池的工具类。1.2.线程数量固定的线程池ExecutorServiceexecutorService=Executors.newFixedThreadPool(2);for(intj=0;j<10;j++){final...
Java 的锁 -- 具体的锁对象及其实现原理
十七的博客
11-28 2228
锁机制：用来保证在多线程并发情况下数据的一致性。 锁的作用点：操作一个对象或者调用一个方法前加锁，这样当其他线程也对该对象和方法进行访问时就需要获得锁，如果该锁被其他线程持有，那么该线程则进入阻塞队列等待获得锁。 Java 中，用作锁的对象有：synchronized、ReentrantLock、ReadWriteLock、volatile。 synchronized：同步锁。 ReentrantLock：可重入锁。 ReadWriteLock：读写锁。
详解java 对象锁与类锁
09-07
主要介绍了java 对象锁与类锁的相关资料，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下
Java对象锁和类锁全面解析（多线程synchronize
11-22
Java对象锁和类锁全面解析（多线程synchronized关键字）编程开发技术共14页.pdf.zip
Java类锁、对象锁、私有锁冲突测试
09-04
主要介绍了Java类锁、对象锁、私有锁冲突测试,得出结论是加锁方法够成了竞争关系,同一时刻只能有一个方法能执行,需要的朋友可以参考下
详解Java同步—线程锁和条件对象
08-27
在这篇文章中给大家详细讲述了Java同步—线程锁和条件对象的相关知识点，有需要的读者们可以参考下。
API 调用次数限制实现
07-03
我们在开发接口服务器的过程中，为了防止客户端对于接口的滥用，保护服务器的资源， 通常来说我们会对于服务器上的各种接口进行调用次数的限制。
Java并发编程：理解多线程并发问题及其解决方法
weixin_40754174的博客
04-03 3964
java并发编程 多线程 解决方法 示例 锁 并发编程性能优化
Java synchronized类锁，对象锁详解
m0_72336997的博客
09-29 3847
synchronized的对象锁和类锁详解
java 对象锁_Java的对象锁
weixin_33623134的博客
02-12 1280
内置锁Java提供了一种内置的锁机制来支持原子性和可见性：同步代码块(Synchronized Block)。同步代码块包括两部分：一个是作为锁的对象引用，一个是锁保护的代码块。每一个Java对象都可以用做一个实现同步的锁，这种锁被称为内置锁(Intrinsic Lock)或者监视器锁(Monitor Lock)。线程进入同步代码块之前会自动获得锁，并且在退出同步代码块时(正常返回，或者是异常退出...
面试常问问题：银行网上支付项目中怎么控制多线程高并发访问？
热门推荐
静心梦工厂
04-02 1万+
银行网上支付项目中怎么控制多线程高并发访问？
关于java中并发时引起的问题（多线程问题）
u010523770的专栏
06-24 1972
场景如下： 我有一个订单导入页面，如下图： 公司里面有很多员工，都需要进入这个页面，进行订单导入。 并发进行，可能存在这样的问题，两个同事，同时输了一个相同的订单号，同时点击订单导入，同时导入成功。 那么数据库中就会存在两条一模一样的订单数据。 上面的问题是多线程引发的最常见的问题了。 解决思路如下： 1：首先每次订单导入的时候，调用订单查询方法，先查询一次数据库中是
后端开发是一个涉及广泛技术和工具的领域.docx
最新发布
04-30
后端开发是一个涉及广泛技术和工具的领域，这些资源对于构建健壮、可扩展和高效的Web应用程序至关重要。以下是对后端开发资源的简要介绍： 首先，掌握一门或多门编程语言是后端开发的基础。Java、Python和Node.js是其中最受欢迎的几种。Java以其跨平台性和丰富的库而著名，Python则因其简洁的语法和广泛的应用领域而备受欢迎。Node.js则通过其基于JavaScript的单线程异步I/O模型，为Web开发提供了高性能的解决方案。 其次，数据库技术是后端开发中不可或缺的一部分。关系型数据库（如MySQL、PostgreSQL）和非关系型数据库（如MongoDB、Redis）各有其特点和应用场景。关系型数据库适合存储结构化数据，而非关系型数据库则更适合处理大量非结构化数据。 此外，Web开发框架也是后端开发的重要资源。例如，Express是一个基于Node.js的Web应用开发框架，它提供了丰富的API和中间件支持，使得开发人员能够快速地构建Web应用程序。Django则是一个用Python编写的Web应用框架，它采用了MVC的软件设计模式，使得代码结构更加清晰和易于维护。
华为数字化转型实践28个精华问答glkm.pptx
04-30
华为数字化转型实践28个精华问答glkm.pptx
新员工入职培训全流程资料包gl.zip
04-30
新员工入职培训全流程资料包（100+个文件） 1入职流程指引 万科新职员入职通知书 万科新职员入职引导手册 新进员工跟进管理表 新员工入职报到工作单(文职) 新员工入职报到流程 新员工入职流程表 新员工入职手续办理流程(工厂 新员工入职手续清单 新员工入职须知 新员工入职训流程 新员工入职引导表(导师用) 2 入职工具表格 3 培训方案计划 4培训管理流程 5培训教材课件 6 培训效果检测 7 员工管理制度 8 劳动合同协议 9 新员工培训PPT模板(28套)
java对象头与monitor锁
03-28
Java对象头是一个固定大小的数据结构，它包含了对象的元数据信息，如对象的类型、状态信息、锁状态等。在Java虚拟机中，每个对象都有一个对象头，它位于对象内存布局的最前面。 在Java中，每个对象都有一个关联的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值