Java :使用Synchronized和Lock获得对象锁

最新推荐文章于 2022-11-28 00:31:54 发布
最新推荐文章于 2022-11-28 00:31:54 发布
阅读量73 收藏
点赞数
分类专栏： java 文章标签： synchronized lock thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guojianhui0906/article/details/84041111
版权
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。
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()
guojianhui0906
关注
专栏目录
Java并发编程3 —— 对象锁和类锁
扎瓦菜鸟
09-11 514
synchronized关键字作用在同步代码块上，给共享变量“上锁”可以解决线程安全问题。这把“锁”可以作用在某个对象上，也可以作用在某个类上。 举个栗子，有个自助银行，里面有两台ATM机，工作人员可以看到每次存取款之后机器里钞票的总金额数。现在有两个人来存钱，各存50元。 没有锁 在下面的代码中，两个线程t1、t2相当于两个人，每个Service对象相当于一台ATM机。这里先只创建了一个S...
Java中synchronized与Lock的区别与使用
最新发布
fudaihb的博客
12-04 1772
当我们谈论Java多线程编程时，线程同步是一个避免资源竞争和保证线程安全的关键概念。在Java中，主要有两种机制来实现线程同步：synchronized关键字和Lock接口。这篇博客将详细介绍这两种同步机制的区别和使用方法，并通过示例来加深理解。
Java:使用synchronized和Lock对象获取对象锁
anreddy
11-11 96
来源：[url]http://zhangjunhd.blog.51cto.com/113473/70300[/url] 在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。 1.对象的锁 所有对象都自动含有单一的锁。 JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会...
Java多线程----java 对象锁
热门推荐
ymeng_bupt的专栏
09-27 3万+
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。 1. 对象锁       所有对象都自动含有单一的锁。      JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在
Java线程(十)：锁对象Lock-同步问题更完美的处理方式
persistence勿忘初心
03-11 216
https://blog.csdn.net/persistencegoing/article/details/84376427 Lock是java.util.concurrent.locks包下的接口，Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题，我们拿Java线程(二)中的一个例子简单的实现一下和sychro...
Java 中的Lock锁对象(ReentrantLock/ReentrantReadWriteLock)详解
swadian2008的博客
08-29 3437
当有线程获取读锁时，如果当前没有线程持有写锁，则读锁将立即被获取，读锁计数器加一，表示当前有一个线程持有读锁。在 getValue() 方法中，线程会获取锁，返回共享变量 value 的值，最后释放锁。例如，如果一个线程在尝试获取锁的过程中遇到了饥饿现象（即一直获取不到锁），那么系统可能会采用类似于睡眠的方式，让该线程暂时让出 CPU 资源，等待一段时间后再次尝试获取锁。接着，它获取读锁，释放写锁，这样就实现了锁降级。这是因为写锁是独占锁，不能被多个线程同时持有，而读锁是共享锁，可以被多个线程同时持有。
Synchronized 和 Lock 的区别和使用场景
01-20
本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...
synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
《深入剖析synchronized锁原理——从Java对象头的角度》 synchronized关键字在Java中扮演着重要的角色，它是Java实现同步的基础，确保了多线程环境下的数据一致性。不同于基于JDK实现的Lock接口（如ReentrantLock）...
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例
08-28
Java中的锁对象Lock是java.util.concurrent.locks包下的接口，提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。它能以更优雅的方式处理线程同步问题。Lock的实现可以提供比synchronized更好的性能和...
Java synchronized关键字和Lock接口实现原理
08-25
Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。...
Java 的锁 -- 具体的锁对象及其实现原理
十七的博客
11-28 2872
锁机制：用来保证在多线程并发情况下数据的一致性。 锁的作用点：操作一个对象或者调用一个方法前加锁，这样当其他线程也对该对象和方法进行访问时就需要获得锁，如果该锁被其他线程持有，那么该线程则进入阻塞队列等待获得锁。 Java 中，用作锁的对象有：synchronized、ReentrantLock、ReadWriteLock、volatile。 synchronized：同步锁。 ReentrantLock：可重入锁。 ReadWriteLock：读写锁。
Java对象锁的理解
Chujian的博客
07-16 2万+
Java 以前理解Java的锁机制认为：锁的类型分为‘类锁’，’方法锁‘，’对象锁‘。 1.类锁(synchronize(静态对象))：类的所有对象都要竞争锁。 2.方法锁(在方法前加synchronize)： 同一对象同一方法需要竞争锁。 3.对象锁(synchronize(对象))：同一对象代码块竞争锁。 以上都是在学习Java锁的基础理解 其实上面所有的锁，都是“对象锁” 类锁...
Java Lock对象
假装你是大灰狼的专栏
12-03 3256
1. ReentrantLock类 ReentrantLock可以实现线程之间同步互斥，类似于synchronized同样的效果。 public class ThreadReentrantLock { public static void main(String[] args) { ThreadA threadA = new ThreadA(); for...
java 对象 lock_Java:使用synchronized和Lock对象获取对象锁
weixin_36073714的博客
02-15 281
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 类锁如何获得_Java Synchronized获得类的锁和获得对象的锁有什么区别呢？
weixin_32655655的博客
02-26 199
对象锁&类锁对象锁当一个对象中有synchronized method或synchronized block的时候调用此对象的同步方法或进入其同步区域时，就必须先获得对象锁。如果此对象的对象锁已被其他调用者占用，则需要等待此锁被释放同步静态方法/静态变量互斥体由于一个class不论被实例化多少次，其中的静态方法和静态变量在内存中都只由一份。所以，一旦一个静态的方法被申明为synchroni...
java中Lock类的使用
qq_41889292的博客
08-10 3698
1.使用ReentrantLock类： private Lock ticklock=new ReentrantLock(); 调用ReentrantLock对象的lock()方法获取锁，调用unlock()方法释放锁。 范例： public class MyThread{ private Lock lock=new ReentrantLock(); public...
java 对象 lock_实现自己的Lock对象
weixin_31582915的博客
02-21 344
一直想好好学习concurrent包中的各个类的实现，然而经常看了一点就因为其他事情干扰而放下了。发现这样太不利于自己的成长了，因而最近打算潜心一件一件的完成自己想学习的东西。对concurrent包的学习打算先从Lock的实现开始，因而自然而然的就端起了AbstractQueuedSynchronizer，然而要读懂这个类的源码并不是那么容易，因而我就开始问自己一个问题：如果自己要去实现这个一个...
java synchronized类锁，对象锁详解（转载）
runrun117的博客
03-26 423
java synchronized类锁，对象锁详解（转载）对象锁：1、一个对象中所有方法都上了synchronized，运行的时候就会互斥运行，不会同时运行。以为两个同步代码所需要获得的对象锁都是同一个对象锁。2、一个对象一个方法有锁，一个方面没有锁，那么这个对象执行这两个方法的时候是不会互斥的，进行了同步的方法（加锁方法）和没有进行同步的方法（普通方法）是互不影响的，一个线程进入了同步方法，得到...
Java并发编程专题系列：深入Synchronized&Lock&AQS
资源摘要信息: "本专题文件集名为'并发编程专题08.zip'，面向Java语言，详细解析了Java中的同步机制，特别是关键字synchronized、锁Lock机制以及抽象同步队列（AQS，AbstractQueuedSynchronizer）的使用和原理。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值