精华内容
下载资源
问答
  • 多线程-Java中的对象监视器什么意思? 为什么要使用这个词?在阅读有关Java线程的文章时,我经常注意到这样的表达:“当前线程是该对象的监视器的所有者”。 我的意思是:线程有权在对象上进行操作。 但是我很困惑...

    多线程-Java中的对象监视器是什么意思? 为什么要使用这个词?

    在阅读有关Java线程的文章时,我经常注意到这样的表达:“当前线程是该对象的监视器的所有者”。 我的意思是:线程有权在对象上进行操作。 但是我很困惑,为什么我们使用“对象的监视器”而不是“对象的锁”?

    简而言之,我不知道“监控”一词的含义这个问题可能很奇怪而且很简单。 但我希望任何人都能帮助解决它。3KS

    6个解决方案

    44 votes

    但是我很困惑,为什么要使用“对象的监视器”一词而不是“对象的锁”?

    请参阅ulmangt的答案以获取在此上下文中解释“监视”一词的链接。

    为什么使用术语“监视”而不是“锁定”? 严格来说,这些术语的含义确实有所不同……尤其是如果您以最初打算使用的方式使用它们。

    “锁”是指具有获取和释放原语的东西,这些原语和原语保持某些锁属性。 例如 专用或单作者/多读者。

    “监视程序”是一种机制,可确保在任何给定时间只有一个线程可以执行给定的代码段。 可以使用锁(和“条件变量”,允许线程等待或通知满足条件的其他线程)来实现此功能,但它不仅仅是锁。 实际上,在Java情况下,不能直接访问监视器使用的实际锁。 (您不能说“ Object.lock()”来阻止其他线程获取它,就像使用Java Lock实例一样。)

    简而言之,如果要学究的话,“ monitor”实际上是比“ lock”更好的术语,用于描述Java提供的特性。 但是实际上,这两个术语几乎可以互换使用。

    Stephen C answered 2019-09-24T08:12:08Z

    20 votes

    监视器只是一个对象的术语,其方法可以在多线程环境中安全使用。

    在Monitors上有一篇很棒的Wikipedia文章:

    [http://en.wikipedia.org/wiki/Monitor_(synchronization)]

    如果向下滚动,甚至还会有专门关于Java的部分。

    ulmangt answered 2019-09-24T08:12:54Z

    5 votes

    它的监视器是object周围的synchronized块,它控制对象上的锁定。 这是一个例子

    synchronized (object) {

    while ()

    object.wait(timeout);

    ... // Perform action appropriate to condition

    }

    abbas answered 2019-09-24T08:13:20Z

    4 votes

    尽管现在回答这个问题已经很晚了,但我还是想补充一下,以防万一。

    这是未同步的Java方法中的Java代码的同步块

    public void add(int value){

    synchronized(this){

    this.count += value;

    }

    }

    在示例“ this”中,使用了add方法。同步实例方法将其所属的对象用作监视对象。

    =>在同一监视对象上同步的Java代码块内只能执行一个线程。

    aman answered 2019-09-24T08:14:13Z

    2 votes

    Java虚拟机使用监视器来支持多线程。 监视器通过两个概念实现这一点-运行线程时互斥(这里是“锁定”的地方)和作为线程间通信手段的协调(这里是对象的wait和notify方法的地方)。

    从“ Inside JVM”中阅读以下部分将清除这个疑问,在这里是否很好解释(第20章,线程同步)-

    [https://www.artima.com/insidejvm/ed2/threadsynchP.html]

    adityalad answered 2019-09-24T08:14:53Z

    2 votes

    从Java虚拟机内部引用

    Java虚拟机中的线程在到达时请求锁定   在监视区域的开头。 在Java中,有两种   监视区域:同步语句和同步方法。

    监控

    监视器就像一栋建筑物,其中包含一个可以   一次只能被一个线程占用。 房间通常包含   一些数据。 从线程进入这个房间的时间到它进入的时间   离开后,它可以独占访问房间中的任何数据。 进入   监视程序的建立称为“进入监视程序”。 进入   建筑物内的特殊房间称为“获取显示器”。   占领房间称为“拥有显示器”,然后离开房间   房间被称为“释放显示器”。 离开整个建筑是   称为“退出监视器”。

    监视器除了与少量数据相关联之外,   与一个或多个代码位相关联,在本书中   称为监视区域。

    如前所述,该语言提供了两种内置方法   识别程序中的监视区域:同步语句和   同步方法。 这两种机制,实现了相互   Java虚拟机支持同步的排除方面   机器的指令集。

    为了实现监视器的互斥功能,Java   虚拟机将锁(有时称为互斥锁)与每个   对象和类。 锁就像特权,只有一个线程可以   随时“拥有”。

    允许单个线程多次锁定同一对象。 对于   每个对象,Java虚拟机都会维护一个数量的计数   对象被锁定的次数。 解锁对象的数量为   零。 当线程首次获取锁时,计数为   再次增加到一。 每次线程获得对   同一对象,计数再次增加。

    Zane XY answered 2019-09-24T08:16:16Z

    展开全文
  • When reading articles about Java threads, I often notice the expression: "current thread is the owner of this object's monitor". I get the meaning: the thread gets the right to operate on the object....

    When reading articles about Java threads, I often notice the expression: "current thread is the owner of this object's monitor". I get the meaning: the thread gets the right to operate on the object. But I am puzzled why we use the phrase "the object's monitor" instead of "the object's lock"?

    In brief, I don't know the meaning of the word 'monitor'

    The question may be strange and simple. But I wish anybody can help to solve it. 3ks

    解决方案

    but I am puzzled why use word "the object's monitor" instend of "the object's lock"?

    See ulmangt's answer for links that explain the term "monitor" as used in this context.

    Why use the term "monitor" rather than "lock"? Well strictly speaking, the terms do mean different things ... especially if you use them in the way that they were originally intended to be used.

    A "lock" is something with acquire and release primitives that maintain certain lock properties; e.g. exclusive use or single writer / multiple reader.

    A "monitor" is a mechanism that ensures that only one thread can be executing a given section (or sections) of code at any given time. This can be implemented using a lock (and "condition variables" that allow threads to wait for or send notifications to other threads that the condition is fulfilled), but it is more than just a lock. Indeed, in the Java case, the actual lock used by a monitor is not directly accessible. (You just can't say "Object.lock()" to prevent other threads from acquiring it ... like you can with a Java Lock instance.)

    In short, if one were to be pedantic "monitor" is actually a better term than "lock" for characterizing what Java is providing. But in practice, both terms are used almost interchangeably.

    展开全文
  • Java 并发编程之 Condition和Object监视器详解简介在 Java 程序中,任意一个 Java 对象,都拥有一组监视器方法(定义在 java.lang.Object 类上),主要包括 wait()、wait(long)、notify()、notifyAll() 方法,这些方法...

    Java 并发编程之 Condition和Object监视器详解

    简介

    在 Java 程序中,任意一个 Java 对象,都拥有一组监视器方法(定义在 java.lang.Object 类上),主要包括 wait()、wait(long)、notify()、notifyAll() 方法,这些方法与 synchronized 关键字配合,可以实现等待 / 通知模式。Condition 接口也提供了类似 Object 的监视器方法,与 Lock 配合可以实现等待 / 通知模式,但是这两者在使用方式以及功能特性上还是有区别的。Object 的监视器方法与 Condition 接口对比如下:

    对比项

    Object 监视器方法

    Condition

    前置条件

    获取对象的监视器锁

    调用 Lock.lock() 获取锁调用 Lock.newCondition() 获取 Condition 对象

    调用方法

    直接调用如:object.wait()

    直接调用如:condition.await()

    等待队列个数

    一个

    多个

    当前线程释放锁并进入等待队列

    支持

    支持

    当前线程释放锁并进入等待队列,在等待状态中不响应中断

    不支持

    支持

    当前线程释放锁并进入超时等待状态

    支持

    支持

    当前线程释放锁并进入等待状态到将来的某个时间

    不支持

    支持

    唤醒等待队列中的一个线程

    支持

    支持

    唤醒等待队列中的全部线程

    支持

    支持

    Condition 提供了一系列的方法来对阻塞和唤醒线程:

    public interface Condition {

    void await() throws InterruptedException;

    void awaitUninterruptibly();

    long awaitNanos(long nanosTimeout) throws InterruptedException;

    boolean await(long time, TimeUnit unit) throws InterruptedException;

    boolean awaitUntil(Date deadline) throws InterruptedException;

    void signal();

    void signalAll();

    }

    Condition 的方法以及描述如下:

    方法名称

    描 述

    void await() throws InterruptedException

    当前线程进入等待状态直到被通知(signal)或中断。

    void awaitUninterruptibly()

    当前线程进入等待状态直到被通知,该方法不响应中断。

    long awaitNanos(long nanosTimeout) throws InterruptedException

    当前线程进入等待状态直到被通知、中断或者超时,返回值表示剩余超时时间。

    boolean awaitUntil(Date deadline) throws InterruptedException

    当前线程进入等待状态直到被通知、中断或者到某个时间。如果没有到指定时间就被通知,方法返回 true,否则,表示到了指定时间,返回 false。

    void signal()

    唤醒一个等待在 Condition 上的线程,该线程从等待方法返回前必须获得与 Condition 相关联的锁。

    void signalAll()

    唤醒所有等待在 Condition 上的线程,能够从等待方法返回的线程必须获得与 Condition 相关联的锁。

    Condition 的实现分析

    可以通过 Lock.newCondition() 方法获取 Condition 对象,而我们知道 Lock 对于同步状态的实现都是通过内部的自定义同步器实现的,newCondition() 方法也不例外,所以,Condition 接口的唯一实现类是同步器 AQS 的内部类 ConditionObject,因为 Condition 的操作需要获取相关的锁,所以作为同步器的内部类也比较合理,该类定义如下:

    public class ConditionObject implements Condition, java.io.Serializable

    每个 Condition 对象都包含着一个队列(以下称为等待队列),该队列是 Condition 对象实现等待 / 通知功能的关键。

    等待队列

    等待队列是一个 FIFO 队列,在队列中的每个节点都包含了一个线程引用,该线程就是在 Condition 对象上等待的线程,如果一个线程调用了 Condition.await() 方法,那么该线程将会释放锁、构造成节点加入等待队列并进入等待状态。事实上,节点的定义复用了 AQS 中 Node 节点的定义,也就是说,同步队列和等待队列中节点类型都是 AQS 的静态内部类 AbstractQueuedSynchronized.Node。

    一个 Condition 包含一个等待队列,Condition 拥有首节点(firstWaiter)和尾节点(lastWaiter)。当前线程调用 Condition.await() 方法之后,将会以当前线程构造节点,并将节点从尾部加入等待队列,等待队列的基本结构如下图所示:

    75e2b8c56507a50c1cf77a78368b6805.png

    Condition 拥有首尾节点的引用,而新增节点只需要将原来的尾节点 nextWaiter 指向它,并且更新尾节点即可。上述更新过程不需要 CAS 保证,原因在于调用 await() 方法的线程必定是获取了锁的线程,也就是说该过程是由锁来保证线程安全的。

    在 Object 的监视器模型上,一个对象拥有一个同步队列和等待队列,而并发包中的 Lock(更确切地说是同步器)拥有一个同步队列和多个等待队列,其对应关系如下图所示:

    c4315f8bc7cb619ed96c3c303b8a29bc.png

    Condition 的实现是同步器的内部类,因此每个 Condition 实例都能够访问同步器提供的方法,相当于每个 Condition 都拥有所属同步器的引用。

    同步队列:所有尝试获取该对象Monitor失败的线程,都加入同步队列排队获取锁,可以理解为同步队列上的线程都在争用锁对象

    等待队列:已经拿到锁的线程在等待其他资源时,主动释放锁,置入该对象等待队列中,等待被唤醒,当调用notify()会在等待队列中任意唤醒一个线程,将其置入同步队列的尾部,排队获取锁,可以理解为等待队列上的线程是主动暂时放弃争用锁

    等待

    调用 Condition 的 await() 方法会使当前线程进入等待状态,同时线程状态变为等待状态,当从 await() 方法返回时,当前线程一定获取了 Condition 相关联的锁。

    如果从队列(同步队列和等待队列)的角度看 await() 方法,当调用 await() 方法时,相当于同步队列的首节点(获取了锁的节点)移动到 Condition 的等待队列中。

    Condition 的 await() 方法如下:

    public final void await() throws InterruptedException {

    // 检测线程中断状态

    if (Thread.interrupted())

    throw new InterruptedException();

    // 将当前线程包装为Node节点加入等待队列

    Node node = addConditionWaiter();

    // 释放同步状态,也就是释放锁

    int savedState = fullyRelease(node);

    int interruptMode = 0;

    // 检测该节点是否在同步队中,如果不在,则说明该线程还不具备竞争锁的资格,则继续等待

    while (!isOnSyncQueue(node)) {

    // 挂起线程

    LockSupport.park(this);

    if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)

    break;

    }

    // 竞争同步状态

    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)

    interruptMode = REINTERRUPT;

    // 清理条件队列中的不是在等待条件的节点

    if (node.nextWaiter != null) // clean up if cancelled

    unlinkCancelledWaiters();

    if (interruptMode != 0)

    reportInterruptAfterWait(interruptMode);

    }

    调用该方法的线程是成功获取了锁的线程,也就是同步队列中的首节点,该方法会将当前线程构造节点并加入等待队列中,然后释放同步状态,唤醒同步队列中的后继节点,然后当前线程会进入等待状态。

    加入等待队列是通过 addConditionWaiter() 方法来完成的:

    private Node addConditionWaiter() {

    // 尾节点

    Node t = lastWaiter;

    // 尾节点如果不是CONDITION状态,则表示该节点不处于等待状态,需要清理节点

    if (t != null && t.waitStatus != Node.CONDITION) {

    unlinkCancelledWaiters();

    t = lastWaiter;

    }

    // 根据当前线程创建Node节点

    Node node = new Node(Thread.currentThread(), Node.CONDITION);

    // 将该节点加入等待队列的末尾

    if (t == null)

    firstWaiter = node;

    else

    t.nextWaiter = node;

    lastWaiter = node;

    return node;

    }

    如果从队列的角度看,当前线程加入到 Condition 的等待队列,如下图所示:

    e5d4f1d1a017b356eff08b2080ac1125.png

    将当前线程加入到等待队列之后,需要释放同步状态,该操作通过 fullyRelease(Node) 方法来完成:

    final int fullyRelease(Node node) {

    boolean failed = true;

    try {

    // 获取同步状态

    int savedState = getState();

    // 释放锁

    if (release(savedState)) {

    failed = false;

    return savedState;

    } else {

    throw new IllegalMonitorStateException();

    }

    } finally {

    if (failed)

    node.waitStatus = Node.CANCELLED;

    }

    }

    线程释放锁之后,我们需要通过 isOnSyncQueue(Node) 方法不断自省地检查其对应节点是否在同步队列中:

    final boolean isOnSyncQueue(Node node) {

    // 节点状态为CONDITION,或者前驱节点为null,返回false

    if (node.waitStatus == Node.CONDITION || node.prev == null)

    return false;

    // 后继节点不为null,那么肯定在同步队列中

    if (node.next != null) // If has successor, it must be on queue

    return true;

    return findNodeFromTail(node);

    }

    若节点不在同步队列中,则挂起当前线程,若线程在同步队列中,且获取了同步状态,可能会调用 unlinkCancelledWaiters() 方法来清理等待队列中不为 CONDITION 状态的节点:

    private void unlinkCancelledWaiters() {

    Node t = firstWaiter;

    Node trail = null;

    while (t != null) {

    Node next = t.nextWaiter;

    if (t.waitStatus != Node.CONDITION) {

    t.nextWaiter = null;

    if (trail == null)

    firstWaiter = next;

    else

    trail.nextWaiter = next;

    if (next == null)

    lastWaiter = trail;

    }

    else

    trail = t;

    t = next;

    }

    }

    通知

    调用 Condition 的 signal() 方法,将会唤醒在等待队列中等待时间最长的节点(首节点),在唤醒节点之前,会将节点移到同步队列中。Condition 的 signal() 方法如下所示:

    public final void signal() {

    // 判断是否是当前线程获取了锁

    if (!isHeldExclusively())

    throw new IllegalMonitorStateException();

    // 唤醒等待队列的首节点

    Node first = firstWaiter;

    if (first != null)

    doSignal(first);

    }

    该方法最终调用 doSignal(Node) 方法来唤醒节点:

    private void doSignal(Node first) {

    do {

    // 把等待队列的首节点移除之后,要修改首结点

    if ( (firstWaiter = first.nextWaiter) == null)

    lastWaiter = null;

    first.nextWaiter = null;

    } while (!transferForSignal(first) &&

    (first = firstWaiter) != null);

    }

    将节点移动到同步队列是通过 transferForSignal(Node) 方法完成的:

    final boolean transferForSignal(Node node) {

    // 尝试将该节点的状态从CONDITION修改为0

    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))

    return false;

    // 将节点加入到同步队列尾部,返回该节点的前驱节点

    Node p = enq(node);

    int ws = p.waitStatus;

    // 如果前驱节点的状态为CANCEL或者修改waitStatus失败,则直接唤醒当前线程

    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))

    LockSupport.unpark(node.thread);

    return true;

    }

    节点从等待队列移动到同步队列的过程如下图所示:

    54e1b241d64e6524c3819e9f384fe0e4.png

    被唤醒后的线程,将从 await() 方法中的 while 循环中退出(因为此时 isOnSyncQueue(Node) 方法返回 true),进而调用 acquireQueued() 方法加入到获取同步状态的竞争中。

    成功获取了锁之后,被唤醒的线程将从先前调用的 await() 方法返回,此时,该线程已经成功获取了锁。

    Condition 的 signalAll() 方法,相当于对等待队列的每个节点均执行一次 signal() 方法,效果就是将等待队列中的所有节点移动到同步队列中。

    相关博客

    参考资料

    方腾飞:《Java 并发编程的艺术》

    展开全文
  • Java对象监视器Monitor

    2021-05-22 15:46:18
    文章目录一、ObjectMonitor结构体二、Monitor原理 一、ObjectMonitor结构体 ... // 由于synchronized是可重入锁,count用于记录当前对象锁拥有者线程获取锁的次数 _waiters = 0, _recursions = 0;

    一、ObjectMonitor结构体

    Monitor是基于C++代码中的ObjectMonitor结构体实现的。

    ObjectMonitor() {
        _header       = NULL;
        _count        = 0; // 由于synchronized是可重入锁,count用于记录当前对象锁拥有者线程获取锁的次数
        _waiters      = 0,
        _recursions   = 0;
        _object       = NULL;
        _owner        = NULL;
        _WaitSet      = NULL; // 调用了wait方法,处于WAIT/TIME_WAIT的线程,会被加入到WaitSet
        _WaitSetLock  = 0 ;
        _Responsible  = NULL ;
        _succ         = NULL ;
        _cxq          = NULL ;
        FreeNext      = NULL ;
        _EntryList    = NULL ; // 处于等待锁block状态的线程,会被加入到EntryList
        _SpinFreq     = 0 ;
        _SpinClock    = 0 ;
        OwnerIsThread = 0 ;
      }
    

    二、Monitor原理

    在这里插入图片描述
    在Java虚拟机(HotSpot)中,对象监视器主要是基于ObjectMonitor结构体中的EntrySet、WaitSet两个队列以及计数器count实现的。

    1. 当有多个线程同时想获取某个对象锁时,首先会进入EntryList队列
    2. 当某个线程获取到对象锁时,线程成为对象锁的拥有者,准备开始运行加锁代码块时,执行字节码指令monitorenter,此时count ++;
    3. 当对象锁的拥有者线程再次获取锁时,由于synchronized锁是可重入的,此时进行count ++,而不是在EntryList队列中阻塞等待锁;
    4. 每个加锁代码块运行完成或因发生异常退出时,会执行monitorexit字节码指令,此时count --;,当count变为0是,对象锁的拥有者线程释放锁。
    5. 拥有锁的线程在运行过程中调用了wait()方法,那么线程会进入到WaitSet对象,等待被notify()或等待的时间已到,才有可能再次成为对象锁的拥有者。
    展开全文
  • 本文详细介绍了Java对象监视器的概念以及API方法,包括JDK1.5提供的Condition监视器对比。1 对象监视器对象监视器实际上就是与每个对象关联的Monitor对象,也叫做管程锁。实际上监视器也是一个数据结构,里面维护着...
  • synchronized保证线程同步的作用相信大家都已经非常熟悉了,可以把任意一个对象当作锁。synchronized 关键字无论是修饰代码块,还是修饰实例方法和静态方法,本质上都是作用于对象上。多个线程要竞争共享资源,而...
  • Monitor监视器对象

    2021-03-15 17:45:24
    在分析完对象头以后,我们知道对象头里其实是有一个重量级锁的指针,而重量级锁的指针指向的就是monitor监视器对象。 synchronized无论是修饰代码块还是修饰普通方法和静态方法,本质上还都是作用在对象上 为什么说...
  • 1.什么是监视器监视器可以看做包含特殊事物的房间。这个特殊房间一次只能被一个消费者(线程)暂用。这个房间通常包含一些数据和代码。监视器房间如果客户想要占用这个特殊房间,他必须进入走廊(hallWay)才能等到。...
  • How do you turn on and off a monitor from within a Java application?In case you're wondering why, this is a kiosk style application where it would be great to turn off the monitors at night....
  • 监视器模式 java

    2021-03-15 13:37:54
    mutex实际上就是对象本身 } 复制代码什么是监视器模式 java的监视器模式,将对象所有可变状态都封装起来,并由对象自己的内置锁来保护,即是一种实例封闭。 比如hashtable就是运用的监视器模式。 它的get操作就是用的...
  • 线程的监视器,即线程所持有的锁,也就是synchronized所关联的对象。线程的互斥,即同一数据的访问,为了访问数据的同步,维护数据的原子性。线程的互斥 由线程的监视器机制来实现。下面举例几种监视器:1.作用域...
  • java相关:浅谈同步监视器之同步代码块、同步方法发布于 2021-1-19|复制链接下面小妖就为大家带来一篇浅谈同步监视器之同步代码块、同步方法。小妖觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小妖...
  • 什么是管程? 管程保证了同一时刻只有一个进程/线程在管程内对共享变量进行操作,其封装了一套对共享资源访问的模型。其作用是保证多进程或者多线程访问同一个资源时,能够达到“互斥”、“同步”的效果。 管程的...
  • It is true that if clients simultaneously calls increment1() and increment2() methods, then ... 如果您在类中使用私有final字段,而创建的对象只是一个监视器,那么您知道获取该监视器的唯一代码将是您的代码.
  • 我正在开发Android,我无法弄清楚为什么我的一些线程会进入“监视”状态.我读过它可能是因为“同步”问题,但我不确定对象如何不释放它们的锁.任何人都可以帮助如何调试这个或你看到我做错了什么?这是同步对象没有被...
  • Android编程中经常用到内部类的概念 So 复习一下吧~----------概念---------------...匿名内部类是内部类的特殊情况 省略类声明 直接用类体创建对象----------优点-------------使用内部类对象监视器显著减少代码...
  • 监视器对象中的常用方法 1 wait() 1 该方法的是释放代用该方法的监视器锁同时该线程在此处被阻塞 2 阻塞后被唤醒的方式: (1)其他线程中调用了该共享对象的notify()或者notifyAll()方法; (2)其他线程调用了该...
  • 一直对多线程有点迷糊,不知道什么是对象,锁的到底是个什么玩意,最近看了下面这位大佬的解释,感觉很到位一段synchronized的代码被一个线程执行之前,他要先拿到执行这段代码的权限,在Java里 边就是拿到某个...
  • 线程的监视器,即线程所持有的锁,也就是synchronized所关联的对象。线程的互斥,即同一数据的访问,为了访问数据的同步,维护数据的原子性。线程的互斥 由线程的监视器机制来实现。下面举例几种监视器:1.作用域...
  • 这些同步语句中的每一个都被赋予不同的锁定对象.代码如下:public class MyWorker {private Random random = new Random();private Object lock1 = new Object();private Object lock2 = new Object();p...
  • 理解Monitor监视器锁原理 任何一个对象都有一个Monitor与之关联,当且一个...• monitorenter:每个对象都是一个监视器锁(monitor)。当monitor被占用时就会处于锁定状态,线程执行monitorenter指令时尝试获取monito
  • at org.apache.jackrabbit.core.state.SharedItemStateManager.getItemState(SharedItemStateManager.java:257) 这里的要点是两个线程都已锁定监视器(不管它们现在正在等待其他两个监视器)。 在查看“线程转储分析器...
  • 要测试当前线程是否包含监视器,Thread.holdsLock存在!if (!Thread.holdsLock(data)) {throw new RuntimeException(); // complain}这非常快(亚微秒),从1.4开始就可以使用.为了测试一般情况下,哪个线程(或线程ID)...
  • 监视器设计模式的上下文中,监视器的概念是一种基本上可以隐藏相互排斥的构造.这个概念在C Boost中表达,但它在核心C或C中不存在.在C中处理这种类型的作业的方式是使用良好的老式互斥(二进制信号量)和信号量.您可以...
  • 在面试中你可能遇到过这样的问题:锁(lock)和监视器(monitor)有什么区别?嗯,要回答这个问题,你必须深入理解Java的多线程底层是如何工作的。简短的答案是,锁为实现监视器提供必要的支持。详细答案如下。锁(lock)...
  • Java锁和监视器

    2021-03-17 22:21:03
    在Java中,每个对象和Class内部都有一个锁,Class广义上也是一个单例对象,每个对象和Class会和一个监视器关联,注意措辞,锁是存在于对象内部的数据结构,监视器是一个独立的结构但是和对象关联,相同点是对象一定...
  • java锁和监视器

    2021-03-13 11:17:48
    有这么一些话: “在JVM中,每个对象和类在逻辑上都是和一个监视器相关联的,为了实现监视器的排他性监视能力,JVM为每一个对象和类都关联一个锁(内置锁),锁住了一个对象,就是获得对象相关联的监视器”锁为监视器...
  • 2.Ubuntu下软件安装htop 3.htop软件使用(主菜单) F1 帮助信息 (支持鼠标哦) 记住常用的几个快捷键就行 什么t s P M H K等等 F2 一些设置 (这个比较简单) F3 是可以搜索 F4是过滤出哪个进程 F5 就是上面的...
  • 如果对象在调用Object.wait()时不拥有对象监视器,那么在释放监视器之前,它将无法访问对象以设置通知监听器。相反,它将被视为尝试访问同步对象上的方法的线程。或者换句话说,没有区别:public void ...
  • 同步监视器可以是任何对象,必须唯一,保证多个线程获得是同一个对象(锁). 同步监视器的执行过程 1.第一个线程访问,锁定同步监视器,执行其中代码. 2.第二个线程访问,发现同步监视器被锁定,无法访问. 3.第一个线程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 163,759
精华内容 65,503
关键字:

对象监视器是什么