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

最新推荐文章于 2021-02-21 13:48:32 发布
最新推荐文章于 2021-02-21 13:48:32 发布
阅读量79 收藏
点赞数
分类专栏： 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 462
synchronized关键字作用在同步代码块上，给共享变量“上锁”可以解决线程安全问题。这把“锁”可以作用在某个对象上，也可以作用在某个类上。 举个栗子，有个自助银行，里面有两台ATM机，工作人员可以看到每次存取款之后机器里钞票的总金额数。现在有两个人来存钱，各存50元。 没有锁 在下面的代码中，两个线程t1、t2相当于两个人，每个Service对象相当于一台ATM机。这里先只创建了一个S...
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例
08-28
* Lock对象是Java中的一个锁机制，提供了比synchronized方法和语句更好的性能和灵活性。 * Lock对象可以用来解决线程同步问题，提供了比synchronized方法和语句更好的性能和灵活性。 * 在使用Lock对象时，需要注意锁...
Java:使用synchronized和Lock对象获取对象锁
weixin_34260991的博客
04-08 75
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。 1.对象的锁 所有对象都自动含有单一的锁。 JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。 只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。 每当任务离开一个synchr...
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...
java 对象锁和类锁_synchronized对象锁和类锁.
weixin_39765057的博客
02-21 138
对象锁概念Java的所有对象都含有1个互斥锁，这个锁由JVM自动获取和释放。线程进入synchronized方法的时候获取该对象的锁，当然如果已经有线程获取了这个对象的锁，那么当前线程会等待，synchronized方法正常返回或者抛异常而终止，JVM会自动释放对象锁。这里也体现了用synchronized来加锁的一个好处，方法抛异常的时候，锁仍然可以由JVM来自动释放。// 对象锁：形式1(方法...
Java对象锁和类锁全面解析（多线程synchronize
11-22
Java对象锁和类锁是Java多线程编程中至关重要的概念，它们是通过`synchronized`关键字来实现的，用于确保代码在并发环境下的线程安全。在这个全面解析中，我们将深入探讨这两个锁机制，理解它们的工作原理以及如何在...
Synchronized 和 Lock 的区别和使用场景
01-20
3. 锁住整个对象：当`synchronized`后面跟的是`this`或者类实例时，锁住的是整个对象，不允许其他线程同时访问对象的所有`synchronized`方法和代码块。 二、Lock接口 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，提供了尝试获取锁、可中断的锁等待、定时锁等待等功能。使用...
从头认识java-17.4 详解同步（3）-对象锁
raylee2007的专栏
01-11 1742
这一章节我们接着上一章节的问题，给出一个解决方案：对象锁。1.什么是对象锁？对象锁是指Java为临界区synchronized(Object)语句指定的对象进行加锁，对象锁是独占排他锁。2.什么是临界区？临界区是指程序中的一个代码段，在这段代码中，单独并发的线程对同一个对象进行访问。在Java中，用关键字“synchronized”标识一个临界区。3.常用的对象锁：synchronized和Ree
Java Lock对象
假装你是大灰狼的专栏
12-03 3226
1. ReentrantLock类 ReentrantLock可以实现线程之间同步互斥，类似于synchronized同样的效果。 public class ThreadReentrantLock { public static void main(String[] args) { ThreadA threadA = new ThreadA(); for...
java 对象锁_Java synchronized类锁，对象锁详解（转载）
weixin_28706923的博客
02-12 570
在java编程中，经常需要用到同步，而用得最多的也许是synchronized关键字了，下面看看这个关键字的用法。因为synchronized关键字涉及到锁的概念，所以先来了解一些相关的锁知识。java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同...
Java对象锁的理解
热门推荐
Chujian的博客
07-16 2万+
Java 以前理解Java的锁机制认为：锁的类型分为‘类锁’，’方法锁‘，’对象锁‘。 1.类锁(synchronize(静态对象))：类的所有对象都要竞争锁。 2.方法锁(在方法前加synchronize)： 同一对象同一方法需要竞争锁。 3.对象锁(synchronize(对象))：同一对象代码块竞争锁。 以上都是在学习Java锁的基础理解 其实上面所有的锁，都是“对象锁” 类锁...
java synchronized关键字的用法
ws_zhh的专栏
11-03 2930
在java编程中，经常需要用到同步，而用得最多的也许是synchronized关键字了，下面看看这个关键字的用法。 因为synchronized关键字涉及到锁的概念，所以先来了解一些相关的锁知识。   java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入...
Java对象锁和类锁全面解析（多线程synchronized关键字）
weixin_30512043的博客
06-17 859
最近工作有用到一些多线程的东西，之前吧，有用到synchronized同步块，不过是别人怎么用就跟着用，并没有搞清楚锁的概念。最近也是遇到一些问题，不搞清楚锁的概念，很容易碰壁，甚至有些时候自己连用没用对都不知道。 今天把一些疑惑都解开了，写篇文章分享给大家，文章还算比较全面。当然可能有小宝鸽理解得不够深入透彻的地方，如果说得不正确还望指出。 看之前有必要跟某些猿友说一下，...
为什么在Java语言中，每一个对象有一把锁
basycai的博客
01-15 3802
在Java语言中，每一个对象有一把锁。线程可以使用synchronized关键字来获取对象上的锁。synchronized关键字可应用在方法级别(粗粒度锁)或者是代码块级别(细粒度锁)。   java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了
java锁synchronized与lock
最新发布
06-28
### 回答1： Java中的锁机制有两种：synchronized和Lock。 synchronized是Java中最基本的锁机制，它是Java中的内置锁，可以用于同步方法和同步代码块。synchronized锁机制是基于对象的，每个对象都有一个锁，当一个线程访问一个对象时，它会尝试获取这个对象的锁，如果锁已经被其他线程获取了，那么这个线程就会被阻塞，直到获取到锁为止。 Lock是Java中的另一种锁机制，它是Java中的显式锁，需要手动获取和释放锁。Lock锁机制是基于接口的，它提供了更多的灵活性和功能，比如可以设置锁的公平性、可重入性、超时等待等。 总的来说，synchronized是Java中最常用的锁机制，它简单易用，但是功能相对较少；而Lock锁机制则更加灵活，但是使用起来相对复杂一些。在实际开发中，应该根据具体的需求选择合适的锁机制。 ### 回答2： Java中的锁机制是多线程编程中非常重要的一个概念，synchronized和Lock是两种常用的Java锁机制。它们在实现多线程编程时，提供了同步和互斥的功能。然而，在使用时，它们存在一些不同之处。 Synchronized关键字是Java语言内置的锁机制，它是在Java中最简单和最普遍的一种锁机制。当在代码中添加synchronized关键字时，它会锁住当前对象，即monitor（即synchronized后面的锁定对象）。在同步代码块执行前，线程会获得锁，执行完同步代码块后，就会释放锁。只有获得了锁的线程才能执行同步的代码块，其他线程需要等待获取锁。 相比之下，Lock则是Java中的一种更加灵活的锁机制。它提供了更加丰富的同步控制方法和更加灵活的逻辑控制选项。通过使用Lock，线程可以实现更高级别的同步处理，使用ReentrantLock类实现更加细粒度的锁定和解锁操作。 Lock与Synchronized关键字的主要区别在于，Lock是显式地定义锁对象，需要手动获取和释放锁，而Synchronized是隐式的，自动获取和释放锁。此外，在Synchronized机制下，遇到异常会自动释放锁，但在Lock机制下，如果遇到异常需要手动释放锁。 在高并发场景下，Lock的性能更高，更有优势，但是它的使用比Synchronized更加复杂，更容易出现死锁等问题。因此，在实际开发中，应该根据具体的情况来选择使用哪种锁机制。 总的来说，Java的Synchronized和Lock锁机制是Java中实现多线程同步的两种方式，它们的原理和功能都是一致的。但是，它们在使用时存在着不同的特点和优缺点，需要根据实际情况进行选择和应用。 ### 回答3： 在Java编程中，锁是一种有效的控制并发的机制，他们可以确保同一时间内只有一个线程可以访问或修改共享资源。Java中提供了两种主要的锁机制，分别是synchronized和Lock。 Synchronized锁机制： Synchronized是Java中最常用也是最基本的锁机制，它是一个关键字，用于标记一个方法或代码块，以保证同一时间只能有一个线程执行它。在synchronized机制中，每个对象都有一个锁，当某个线程需要访问锁标记的代码时，它必须先申请并获得该对象的锁才能执行相关代码，当线程执行完毕，它会主动释放锁。synchronized机制的优点是简单易用，而且它可以自动解锁，不用担心死锁的问题，但是如果我们需要更加灵活的控制，或者需要更高的性能，就需要使用Lock机制。 Lock锁机制： Lock是Java中提供的另一种锁机制，它对于synchronized机制来说是一个更加灵活、可扩展和高效的替代方案。与synchronized机制相比，Lock机制可以手动控制锁的申请和释放，并且它支持多个条件变量和公平锁。Lock机制需要手动加锁和解锁，需要使用try-catch-finally代码块来确保总是释放锁。Lock机制比synchronized机制在性能上更高效，因为它的加锁过程更为细节化，支持更多的锁类型和粒度，具有更高的灵活性。 总结： 无论是synchronized还是Lock，它们都是Java中的锁机制，但它们的使用场景和实现方式有所不同。synchronized机制适用于对于简单的锁控制，能够自动释放锁，不会产生死锁问题；而Lock机制则更加灵活与可扩展，适用于更为复杂的并发控制场景，可以在性能、加锁粒度、锁类型等方面进行更高级别的控制。无论哪一个锁机制，我们都应该在程序中恰当的选择，并慎重使用，以确保程序的性能和安全。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值