精华内容
下载资源
问答
  • Monitor监视器对象

    2021-03-15 17:45:24
    在分析完对象头以后,我们知道对象头里其实是有一个重量级锁的指针,而重量级锁的指针指向的就是monitor监视器对象。 synchronized无论是修饰代码块还是修饰普通方法和静态方法,本质上还都是作用在对象上 为什么说...

    在分析完对象头以后,我们知道对象头里其实是有一个重量级锁的指针,而重量级锁的指针指向的就是monitor监视器对象。
    synchronized无论是修饰代码块还是修饰普通方法和静态方法本质上还都是作用在对象上

    为什么说本质上synchronized还是作用在对象上(猜测)?

    synchronized分为对象锁和类锁。对象锁,锁的是实例化对象。而类锁加在了类上,会对每一个该类的实例化对象上锁,说白了还是加在对象上。
    类的信息是存放在方法区,该类的每一个实例对象都有一个Kclass point指针(对象头中)指向其类信息。如果类有了锁标志,其实例化对象中的markword的锁标志会修改,从而所有的实例化对象的会拥有相同的锁,也就是拥有相同的monitor。所以本质还是作用在对象上。

    • 不管是类锁还是对象锁,多线程获取锁的本质其实是获取的monitor对象。

    monitor对象长啥样?

    monitor
    当多个线程同时访问一段同步代码时,首先会进入_EntryList队列中,当某个线程获取到对象的monitor后进入_Owner区域并把monitor中的_owner变量设置为当前线程,同时monitor中的计数器_count加1。即获得对象锁。

    若持有monitor的线程调用wait()方法,将释放当前持有的monitor,_owner变量恢复为null,_count自减1,同时该线程进入_WaitSet集合中等待被唤醒。
    在这里插入图片描述

    参考
    Monitor原理
    monitor是什么

    展开全文
  • 理解Monitor监视器锁原理 任何一个对象都有一个Monitor与之关联,当且一个Monitor被持有后,它将处于锁定状态。Synchronized在JVM里的实现都是 基于进入和退出Monitor对象来实现方法同步和代码块同步,虽然具体实现...

    上一篇:synchronized底层原理

    上一篇我们讲解了synchronized底层原理,使用了Monitor监视器锁。 如果仅仅从Java层面,我们是看不出来synchronized在多线程竞争锁资源下一个详细的过程。
    接下来,我们就研究一下Monitor底层原理,让我们一起分析一下synchronized底层是如何竞争锁资源的。

    理解Monitor监视器锁原理

    任何一个对象都有一个Monitor与之关联,当且一个Monitor被持有后,它将处于锁定状态。Synchronized在JVM里的实现都是 基于进入和退出Monitor对象来实现方法同步代码块同步
    虽然具体实现细节不一样,但是都可以通过成对的MonitorEnter和MonitorExit指令来实现。

    1.MonitorEnter和MonitorExit

    1.1 MonitorEnter

    • monitorenter:每个对象都是一个监视器锁(monitor)。当monitor被占用时就会处于锁定状态,线程执行monitorenter指令时尝试获取monitor的所有权,过程如下:

    a. 如果monitor的进入数为0,则该线程进入monitor,然后将进入数设置为1,该线程即为monitor的所有者;

    b. 如果线程已经占有该monitor,只是重新进入,则进入monitor的进入数加1;(体现可重入锁)

    c. 如果其他线程已经占用了monitor,则该线程进入阻塞状态,直到monitor的进入数为0,再重新尝试获取monitor的所有权;

    1.2MonitorExit

    • monitorexit:执行monitorexit的线程必须是object_ref所对应的monitor的所有者。指令执行时,monitor的进入数减1,**如果减1后进入数为0,那线程退出monitor,不再是这个monitor的所有者。**其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。

    1.2.1 解释monitorexit出现两次

    在这里插入图片描述

    monitorexit,指令出现了两次,第1次为同步正常退出释放锁;第2次为发生异步退出释放锁;

    2.为什么只有在同步的代码块或者方法中才能调用wait/notify等方法?

    通过上面两段描述,我们应该能很清楚的看出Synchronized的实现原理,Synchronized的语义底层是通过一个monitor的对象来完成,其实wait/notify等方法也依赖于monitor对象,这就是为什么只有在同步的代码块或者方法中才能调用wait/notify等方法,否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

    Java中的所有对象的顶级父类是Object类,Object 类定义了 wait(),notify(),notifyAll() 方法,底层用的就是monitor机制,这也是为什么synchronize锁的是整个对象。

    3.解释ACC_SYNCHRONIZED

    看一个同步方法:

    package it.yg.juc.sync; 
    public class SynchronizedMethod { 
        public synchronized void method() {   
            System.out.println("Hello World!");   
        }
    }
    

    反编译结果:
    在这里插入图片描述

    从编译的结果来看,方法的同步并没有通过指令 monitorenter 和 monitorexit 来完成(理论上其实也可以通过这两条指令来实现),不过相对于普通方法,其常量池中多了 ACC_SYNCHRONIZED 标示符。

    JVM就是根据该标示符来实现方法的同步的:
    当方法调用时,调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置,如果设置了,执行线程将先获取monitor,获取成功之后才能执行方法体,方法执行完后再释放monitor。在方法执行期间,其他任何线程都无法再获得同一个monitor对象。

    4.小结

    同步方法(无论静态或者非静态)是通过方法中的 access_flags 中设置ACC_SYNCHRONIZED标志来实现;同步代码块是通过 monitorenter(进入锁) 和 monitorexit(释放锁) 来实现。

    两种同步方式本质上没有区别,只是方法的同步是一种隐式的方式来实现,无需通过字节码来完成。两个指令的执行是JVM通过调用操作系统的互斥原语mutex来实现,被阻塞的线程会被挂起、等待重新调度,会导致“用户态和内核态”两个态之间来回切换,对性能有较大影响。

    5.重点:从C++源码分析synchronized底层是如何进行锁资源竞争的

    monitor,可以把它理解为 一个同步工具,也可以描述为 一种同步机制,它通常被 描述为一个对象。与一切皆对象一样,所有的Java对象是天生的Monitor,每一个Java对象都有成为Monitor的潜质,因为在Java的设计中 ,每一个Java对象自打娘胎里出来就带了一把看不见的锁,它叫做内部锁或者Monitor锁。也就是通常说Synchronized的对象锁,MarkWord锁标识位为10,其中指针指向的是Monitor对象的起始地址。

    5.1ObjectMonitor 底层C++源码

    在Java虚拟机(HotSpot)中,Monitor是由ObjectMonitor类实现的,其主要数据结构如下(位于HotSpot虚拟机源码ObjectMonitor.hpp文件,C++实现的):

    class ObjectMonitor {
    public:
    enum {
    OM_OK,                    // no error
    OM_SYSTEM_ERROR,          // operating system error
    OM_ILLEGAL_MONITOR_STATE, // IllegalMonitorStateException
    OM_INTERRUPTED,           // Thread.interrupt()
    OM_TIMED_OUT              // Object.wait() timed out
    };
    ...
    ObjectMonitor() {
    _header       = NULL; // 对象头
    _count        = 0; // 记录该线程获取锁的次数
    _waiters      = 0, // 当前有多少处于wait状态的thread
    _recursions   = 0; // 锁的重入次数
    _object       = NULL;
    _owner        = NULL; // 指向持有ObjectMonitor对象的线程
    _WaitSet      = NULL; // 存放处于wait状态的线程队列
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ; // 存放处于block锁阻塞状态的线程队列
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
    _previous_owner_tid = 0;
    }
    

    解释代码中几个关键属性:
    _count,记录该线程获取锁的次数(就是前前后后,这个线程一共获取了多少次锁);
    _recursions ,锁的重入次数(道格李Lock下的state);
    _owner 对应 The Owner,含义是持有ObjectMonitor对象的线程;
    _EntryList 对应 Entry List,含义是存放处于block锁阻塞状态的线程队列(多线程下,竞争锁失败的线程会进入EntryList队列);
    _WaitSet 对应 Wait Set,含义是存放处于wait状态的线程队列(正在执行代码的线程遇到wait(),会进行WaitSet队列)。

    5.2通过CAS尝试把monitor的_owner字段设置为当前线程;

    void ATTR ObjectMonitor::enter(TRAPS) {
    // The following code is ordered to check the most common cases first
    // and to reduce RTS->RTO cache line upgrades on SPARC and IA32 processors.
    Thread * const Self = THREAD ;
    void * cur ;
    // 通过CAS尝试把monitor的_owner字段设置为当前线程
    cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ;
    if (cur == NULL) {
    // Either ASSERT recursions == 0 or explicitly set recursions = 0.
    assert (_recursions == 0   , "invariant") ;
    assert (_owner      == Self, "invariant") ;
    // CONSIDER: set or assert OwnerIsThread == 1
    return ;
    }
    // 设置之前的owner指向当前线程,说明当前线程已经持有锁,此次为重入,_recursions自增
    if (cur == Self) {
    // TODO-FIXME: check for integer overflow!  BUGID 6557169.
    _recursions ++ ;
    return ;
    }
    // 如果之前_owner指向的BasicLock在当前线程栈上,说明当前线程是第一次进入该monitor
    // 设置recursions为1,owner为当前线程,该线程成功获得锁并返回
    if (Self->is_lock_owned ((address)cur)) {
    assert (_recursions == 0, "internal state error");
    _recursions = 1 ;
    // Commute owner from a thread-specific on-stack BasicLockObject address to
    // a full-fledged "Thread *".
    _owner = Self ;
    OwnerIsThread = 1 ;
    return ;
    }
    

    从上面代码中,可以看出,if (cur == Self)),说明设置之前的owner指向当前线程,说明当前线程已经持有锁,此次为重入,_recursions自增,即 synchronized是一把可重入锁
    synchronized还是一把非公平锁,新的线程进来是可以有抢占优先级的。

    5.3ObjectMonitor中的队列

    ObjectMonitor中有两个队列,_EntryList 和_WaitSet ,用来保存ObjectWaiter对象列表( 每个等待锁的线程都会被封装成ObjectWaiter对象 ),_owner指向持有ObjectMonitor对象的线程,当多个线程同时访问一段同步代码时:

    1. 首先会进入 _EntryList 集合,当线程获取到对象的monitor后,进入 _Owner区域并把monitor中的owner变量设置为当前线程,同时monitor中的计数器count加1;
    2. 若线程调用 wait() 方法,将释放当前持有的monitor,owner变量恢复为null,count自减1,同时该线程进入 WaitSet集合中等待被唤醒;
    3. 若当前线程执行完毕,也将释放monitor(锁)并复位count的值,以便其他线程进入获取monitor(锁);
      同时,Monitor对象存在于每个Java对象的对象头Mark Word中(存储的指针的指向),Synchronized锁便是通过这种方式获取锁的,也是为什么Java中任意对象可以作为锁的原因,同时notify/notifyAll/wait等方法会使用到Monitor锁对象,所以必须在同步代码块中使用。监视器Monitor有两种同步方式:互斥与协作。多线程环境下线程之间如果需要共享数据,需要解决互斥访问数据的问题,监视器可以确保监视器上的数据在同一时刻只会有一个线程在访问。

    6.synchronized获取锁流程(思想)

    这个流程很关键:
    因为它体现的就是synchronized底层是如何设计【同步策略思想】。 并且,这个思想与接下来道格李写的【AQS的同步策略思想】很相似。

    所以,这也是我一直想要突破的地方:
    看源码的时候,最关键的就是思考设计者们设计这套框架,所采用的【思想】。退一万步讲,你可以不记得syn的底层c++源码具体实现,你也可以不用记得lock的Java源码底层的详细实现,但是你必须记住:synchronized和lock实现并发安全的【思想】。
    结果发现:原来Java界的两个同步利器synchronized和lock,底层实现的思想竟然如此相似。

    使用synchronized进行同步。

    1. 我们都知道如果t0,t1,t2在进行获取锁时,如果t0获取锁资源成功(成功的标志:CAS成功把monitor的_owner字段设置为当前线程),
    2. 那么t1和t2是不会立马挂起的,而是先通过CAS自旋的方式再次尝试获取锁,
    3. 如果失败则入队列(EntryList队列)。

    所谓“自旋”,就monitor并不把线程阻塞放入排队队列,而是去执行一个无意义的循环(因为线程阻塞涉及到用户态和内核态切换的问题),循环结束后看看是否锁已释放并直接进行竞争上岗步骤,如果竞争不到继续自旋循环,循环过程中线程的状态一直处于running状态。明显自旋锁使得synchronized的对象锁方式在线程之间引入了不公平。但是这样可以保证大吞吐率和执行效率。

    不过虽然自旋锁方式省去了阻塞线程的时间和空间(队列的维护等)开销,但是长时间自旋也是很低效的。所以自旋的次数一般控制在一个范围内,例如10,50等,在超出这个范围后,线程就进入排队队列。

    结语:

    synchronized底层C++源码分析至此。
    给自己最大的感触就是:我是看完AQS底层Java源码后,在接触到道格李解决同步策略的【思想】后,然后突然想到synchronized是如何解决同步的思想的,继而又研究了synchronized底层是如何解决同步问题的。
    结果发现,二者有着惊人的相似之处:

    1.多线程竞争锁,当某个线程竞争成功,其他线程都是先自旋,如果失败,然后入队列
    2.竞争锁成功的线程,都会被记录在一个变量中,这个变量返回的就是当前竞争锁成功的线程对象;
    3.可重入锁状态都是通过一个变量记录的;


    那么有个问题来了,我们知道synchronized加锁加在对象上,对象是如何记录锁状态的呢?答案是锁状态是被记录在每个对象的对象头(Mark Word)中,下面我们一起认识一下对象的内存布局。

    下一篇:Java对象内存布局

    展开全文
  • Redis的Monitor监视器

    千次阅读 2016-05-29 10:44:19
    redis客户端可以通过执行MONITOR命令,将客户端转换成监视器,接收并打印服务器处理的每个命令请求的相关信息。 当一个客户端从普通客户端变为监视器时,该客户端的REDIS_MONITOR标识会被打开。 服务器将所有监视器...
    一  介绍
    客户端可以通过执行MONITOR命令,将客户端转换成监视器,接收并打印服务器处理的每个命令请求的相关信息。
    当一个客户端从普通客户端变为监视器时,该客户端的REDIS_MONITOR标识会被打开。
    服务器将所有监视器都记录在monitors链表中。
    每次处理命令请求时,服务器都会遍历monitors链表,将相关信息发送给监视器。

    当前客户端变身监视器,将服务器当前处理的命令都打印出来。
    除了命令与参数外,还有精确到微妙的时间戳,选择的数据库,客户端的ip,port。
    192.168.1.3:6379> monitor
    OK
    1464487722.534521 [0 10.249.88.69:33846] "get" "fwy"
    1464487728.486523 [0 10.249.88.69:33846] "set" "fwy" "b"
    1464488225.302544 [0 10.249.88.69:45389] "select" "3;"
    1464488230.006471 [0 10.249.88.69:45389] "select" "3"
    1464488232.342483 [3 10.249.88.69:45389] "set" "fwy" "a"

    二  数据结构

    redisServer的slave链表,保存着各个监视器,新来的监视器,会加到链表尾。
    struct redisServer {
        ...
        list *slaves, *monitors;    /* List of slaves and MONITORs */
        ...
    }


    三  算法

    服务器处理客户端发来的命令请求,还会把命令信息发给各个监视器。


    服务器主要是通过replicationFeedMonitors(),来将各个命令信息发给监视器们。
    replication.c/replicationFeedMonitors()
    void replicationFeedMonitors(redisClient *c, list *monitors, int dictid, robj **argv, int argc) {
        /*1.根据命令与参数构造发送给监视器的字符串对象;
          2.遍历各个监视器,把字符串对象发出。
          参数:客户端状态,监视器链表,客户端的dbnum,命令参数与个数
         */
        listNode *ln;
        listIter li;
        int j;
        sds cmdrepr = sdsnew("+");
        robj *cmdobj;
        struct timeval tv;

        gettimeofday(&tv,NULL);

        // 创建要发给各个监视器的信息
        cmdrepr = sdscatprintf(cmdrepr,"%ld.%06ld ",(long)tv.tv_sec,(long)tv.tv_usec);

        // 发送给监视器的信息要包含该客户端的ip,port,但如果是lua脚本客户端与unixsocket客户端,就没有port了,但也需要打印它们的信息,比如来自于哪个unixsocket
        if (c->flags & REDIS_LUA_CLIENT) {
            cmdrepr = sdscatprintf(cmdrepr,"[%d lua] ",dictid);
        } else if (c->flags & REDIS_UNIX_SOCKET) {
            cmdrepr = sdscatprintf(cmdrepr,"[%d unix:%s] ",dictid,server.unixsocket);
        } else {
            cmdrepr = sdscatprintf(cmdrepr,"[%d %s] ",dictid,getClientPeerId(c));
        }

        // 命令与参数输出,如果是int则用%ld输出,否则用字符串输出
        for (j = 0; j < argc; j++) {
            if (argv[j]->encoding == REDIS_ENCODING_INT) {
                cmdrepr = sdscatprintf(cmdrepr, "\"%ld\"", (long)argv[j]->ptr);
            } else {
                cmdrepr = sdscatrepr(cmdrepr,(char*)argv[j]->ptr,
                            sdslen(argv[j]->ptr));
            }
            // 如果是最后一个参数
            if (j != argc-1)
                cmdrepr = sdscatlen(cmdrepr," ",1);
        }
        cmdrepr = sdscatlen(cmdrepr,"\r\n",2);
        // 创建一个字符串对象cmdobj
        cmdobj = createObject(REDIS_STRING,cmdrepr);

        // 迭代各个监视器,把信息输出
        listRewind(monitors,&li);
        while((ln = listNext(&li))) {
            redisClient *monitor = ln->value;
            addReply(monitor,cmdobj);
        }
        // 减少其引用计数让服务器一会自动回收
        decrRefCount(cmdobj);
    }


    四 客户端

    客户端发送  monitor 命令
    redis.c/ monitorCommand()    

    // 客户端发送monitor命令的处理函数
    void monitorCommand(redisClient *c) {
        /* ignore MONITOR if already slave or in monitor mode */
        // 如果已经是slave模式,或monitor模式(monitor模式的也会打开slave模式),则不理会.
        if (c->flags & REDIS_SLAVE) return;

        // 客户端置位为monitor标记,还会置位为slave.
        c->flags |= (REDIS_SLAVE|REDIS_MONITOR);

        // 把客户端增加到server.monitors链表的表尾
        listAddNodeTail(server.monitors,c);

        // 回复OK
        addReply(c,shared.ok);
    }



    展开全文
  • ProcessMonitor监视器

    2010-11-07 22:39:01
    软件自家出品的监视软件,监视系统的常规变化。
  • 异步线程monitor监视器

    2017-03-20 11:30:34
    讲其本质,首先就要明确monitor的概念,Java中的每个对象都有一个监视器,来监测并发代码的重入。在非多线程编码时该监视器不发挥作用,反之如果在synchronized 范围内,监视器发挥作用。 wait/notify必须存在于...

    他们是应用于同步问题的人工线程调度工具。讲其本质,首先就要明确monitor的概念,Java中的每个对象都有一个监视器,来监测并发代码的重入。在非多线程编码时该监视器不发挥作用,反之如果在synchronized 范围内,监视器发挥作用。

    wait/notify必须存在于synchronized块中。并且,这三个关键字针对的是同一个监视器(某对象的监视器)。这意味着wait之后,其他线程可以进入同步块执行。

    当某代码并不持有监视器的使用权时(如图中5的状态,即脱离同步块)去wait或notify,会抛出java.lang.IllegalMonitorStateException。也包括在synchronized块中去调用另一个对象的wait/notify,因为不同对象的监视器不同,同样会抛出此异常。


    synchronized, wait, notify结合:典型场景生产者消费者问题

    复制代码
    /**
       * 生产者生产出来的产品交给店员
       */
      public synchronized void produce()
      {
          if(this.product >= MAX_PRODUCT)
          {
              try
              {
                  wait();  
                  System.out.println("产品已满,请稍候再生产");
              }
              catch(InterruptedException e)
              {
                  e.printStackTrace();
              }
              return;
          }
    
          this.product++;
          System.out.println("生产者生产第" + this.product + "个产品.");
          notifyAll();   //通知等待区的消费者可以取出产品了
      }
    
      /**
       * 消费者从店员取产品
       */
      public synchronized void consume()
      {
          if(this.product <= MIN_PRODUCT)
          {
              try 
              {
                  wait(); 
                  System.out.println("缺货,稍候再取");
              } 
              catch (InterruptedException e) 
              {
                  e.printStackTrace();
              }
              return;
          }
    
          System.out.println("消费者取走了第" + this.product + "个产品.");
          this.product--;
          notifyAll();   //通知等待去的生产者可以生产产品了
      }
    复制代码





    不能用try,catch来获取线程中的异常

    展开全文
  • JavaMonitor 监视器

    千次阅读 2019-07-08 11:13:29
    Java的每个对象中都有一个锁(monitor,也可以成为监视器) 并且wait(),notify()等方法用于等待对象的锁或者通知其他线程对象的监视器可用。在Java的线程中并没有可供任何对象使用的锁和同步器。这就是为什么这些方法...
  • C#多线程 Monitor监视器

    2020-10-16 17:18:08
    1.Monitor.Enter()、Monitor.Exit() 概要:Thread1和Thread2在加锁前,对共同的方法,是谁抢到资源谁就执行——加锁后,必须是一个线程执行完毕,另一个线程才会执行。 加锁前: using System; using System....
  • 1)在Eclipse中Windows→Show View→Others→Debug→TCP...3)点击Add,在Local monitoring port处填写监视器的端口号(比如8888)  在Host name处填写想要拦截的地址(localhost)  在Port处填写想要拦截的端口号(...
  • synchronized底层原理—Monitor监视器

    千次阅读 2020-05-31 07:52:31
    Monitor类2. 管程3. ObjectMonitor4. _WaitSet5. _EntryList6. ObjectWaiter3. 对象头1. 轻量级锁2. 重量级锁4. 总结参考 sychronized——java多线程锁的关键字 1. 作用 多线程情况下,同步代码的互斥访问 有效的...
  • 一:Monitor  Monitor是一个同步工具,相当于操作系统中的互斥量(mutex),即值为1的信号量。  它内置与每一个Object对象中,相当于一个许可证。拿到许可证即可以进行操作,没有拿到则需要阻塞等待。    二...
  • 文章目录Monitor监视器java对象头Monitor Monitor监视器 每一个对象都有一个monitor与之关联,当且一个monitor被持有后,它将处于锁定状态。线程执行到monitorenter 指令时,将会尝试获取对象所对应的monitor的...
  • 内容索引:VB源码,网络相关,服务器,信息监控 Server Monitor服务监视器,用以监视服务器的各种运行信息,包括系统信息、硬件信息、IP访问日志等。基于VB代码实现,为你学习VB编程提供参考。
  • MACOS 网速监视器 Network Speed MonitorMACOS 网速监视器 Network Speed Monitor
  • 进程监视 能监测并查看系统中的各个进程及其相关信息 对程序开发研究资源调用、调试等很有帮助。
  • gnome-system-monitor系统监视器 gnome-system-monitor是支持linux的一款系统监视器,可以用于实时监控系统中运行线程的实时占用内存情况
  • 该工具可以在windows系统的工具栏显示实时网速,非常方便查看网络情况
  • BrewBench监视器 BrewBench是面向家庭酿酒者和专业酿酒者的Arduino酿酒监视器,控制器和警报系统。 它使用Arduino REST API与温度传感器接口。 信息管理系统 您也可以将继电器连接到数字端口,并添加加热器/泵以...
  • API MONITOR API 监视器

    2010-10-21 11:06:23
    API Monitor is a software that allows you to spy and display Win32 API calls made by applications. It can trace any exported APIs and display wide range of information, including function name, call ...
  • fdfs监视器 fdfs监视器
  • 监视器monitor

    2020-10-19 12:40:23
    监视器是操作系统实现同步的概念,一个监视器往往一个对象引用相关联,当一个监视器开始监视某一段代码时,其他的线程就需要拥有这个监视器对应的对象,监视器确认后才能让这个线程放行,继续执行后面的代码。...
  • priveos-monitor 非常少的监视器来检查节点运行状况 部署在这里: :
  • 其中包括:Data Collector Monitor、Breaking Point Monitor、User-Definition Monitor、Write-In-File Monitor以及各 类型监视器使用到的函数、异常处理、输出设置等。文档为英文版,但是简单易懂。
  • TCP/IP 监视器 monitor

    2012-09-26 15:53:44
    TCP monitor增强版是一款监视网络状况(如流量、端口、连接网络的进程等)的软件
  • Java并发监视器-Monitor

    2020-04-29 11:40:18
    文章目录一、阅读本文须知二、Monitor的特性三、实现Monitor的三要素四、Java中Monitor的实现 一、阅读本文须知 信号量(Semaphore):在多线程环境下使用的一种设施,可以用来保证两个或多个关键代码段不被并发调用...
  • process monitor.vi 进程监视器

    热门讨论 2012-11-03 19:24:20
    进程监视器,直接导入,老版本中在activity目录下,labview2009找不到了,直接下载
  • 查看系统的内存情况。
  • layer7-monitor 七层监视器
  • 1. InnoDB Monitor 类型 有四类InnoDB monitor:Standard Monitor、Lock Monitor、Tablespace Monitor、Table Monitor。其中Tablespace Monitor和Table Monitor将在后续版本...Standard Monitor监视活动事务持...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,346
精华内容 18,138
关键字:

monitor监视器