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

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量76 收藏
点赞数
分类专栏： java编程 文章标签： java thread object 任务 string class
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。
  
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()
注：本文转自http://zhangjunhd.blog.51cto.com/113473/70300
cmingjun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程3 —— 对象锁和类锁
扎瓦菜鸟
09-11 459
synchronized关键字作用在同步代码块上，给共享变量“上锁”可以解决线程安全问题。这把“锁”可以作用在某个对象上，也可以作用在某个类上。 举个栗子，有个自助银行，里面有两台ATM机，工作人员可以看到每次存取款之后机器里钞票的总金额数。现在有两个人来存钱，各存50元。 没有锁 在下面的代码中，两个线程t1、t2相当于两个人，每个Service对象相当于一台ATM机。这里先只创建了一个S...
Lock接口与synchronized关键字
04-19
而Lock接口则是一个更底层的同步机制，它提供了更丰富的功能，但需要显式地获取和释放锁，通常通过实现类如ReentrantLock来使用。 其次，从功能特性上来看，synchronized具有可重入性，即同一个线程可以多次获取同...
Java:使用synchronized和Lock对象获取对象锁
weixin_34260991的博客
04-08 73
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。 1.对象的锁 所有对象都自动含有单一的锁。 JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。 只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。 每当任务离开一个synchr...
java 对象 lock_Java:使用synchronized和Lock对象获取对象锁
weixin_36073714的博客
02-15 249
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...
java 对象锁和类锁_synchronized对象锁和类锁.
weixin_39765057的博客
02-21 133
对象锁概念Java的所有对象都含有1个互斥锁，这个锁由JVM自动获取和释放。线程进入synchronized方法的时候获取该对象的锁，当然如果已经有线程获取了这个对象的锁，那么当前线程会等待，synchronized方法正常返回或者抛异常而终止，JVM会自动释放对象锁。这里也体现了用synchronized来加锁的一个好处，方法抛异常的时候，锁仍然可以由JVM来自动释放。// 对象锁：形式1(方法...
再也不怕面试官问：详解Synchronized和Lock的实现原理及使用场景
Hanko的专栏
04-18 676
一般情况建议使用Synchronized，在JDK1.5之前Lock优于Synchronized，但在JDK1.5之后对Synchronized进行了优化，后面在性能方面基本与Lock一样且使用简单(有作者说"Synchronized是亲生的，JDK还是会一直优化他不会让Lock优于它")。
Java多线程5：synchronized和Lock区别
何哥的博客
09-06 792
一、锁类型 可重入锁：在执行对象中所有同步方法不用再次获得锁 　　 可中断锁：在等待获取锁过程中可中断 　　 公平锁： 按等待获取锁的线程的等待时间进行获取，等待时间长的具有优先获取锁权利 　　 读写锁：对资源读取和写入的时候拆分为2部分处理，读的时候可以多线程一起读，写的时候必须同步地写 线程安全 这个概念可能是在多线程编程中提及最多的一个概念了。关于这个概念，我觉得好多人都有一个误区，包括我自己一开始也是这样的。我一开始认为线程安全讲的是某个共享变量线程安全，其实我们所说的线程安全是指某段代
Java锁机制，synchronized和lock详解。
记录开发日常笔记
08-16 6834
Java锁机制详解
10-锁（synchronized和Lock）
titanium的博客
02-22 2887
锁（synchronized和lock）
java的Lock锁原理详解.docx
07-04
同样是锁，先说说synchronized和lock的...2.synchronized可以锁住代码块，对象和类，但是线程从开始获取锁之后开发者不能进行控制和了解；lock则用起来非常灵活，提供了许多api可以让开发者去控制加锁和释放锁等等。
java关键字Synchronized详解
07-04
此时，如果其他线程试图获取该对象的锁，JVM会将对象头中的Mark Word(指向对象头的指针)设置为偏向锁标识。这样，只有当前线程才能访问该对象，其他线程需要等待偏向锁失效后才能继续执行。 当一个线程释放偏向锁时...
Java并发显式锁和显式条件队列
12-22
　在类中利用synchronized修饰的方法或者this代码块，均使用的是类的实例锁或者类的锁。这些锁都称为内置锁。 　可以利用显式锁进行协调对象的访问。即ReentrantLock。这是一种可以提供无条件，可轮询，定时以及...
大厂真题之字节跳动-Java初级
06-06
Java 为程序加锁的方式主要有两种：synchronized 与 Lock。 1. synchronized 可以修饰的作用域如下： - 非静态方法（加的锁为对象锁）； - 静态方法（加的锁为类锁）； - 代码块（对象锁与类锁均可）； 2. Lock ...
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 884
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 885
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1202
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 487
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 225
【代码】Java手动启动jar包。
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、付费专栏及课程。

余额充值