java监视器对象（java菜单项加监视器）

今天给各位分享java监视器对象的知识，其中也会对java菜单项加监视器进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

微信号：cloud7591
如需了解更多，欢迎添加客服微信咨询。
复制微信号

本文目录一览：

• 1、Java：Object的监视器模型上，一个对象拥有一个同步队列和等待队列是什么意思？
• 2、java的多线程，对象锁与对象监视器有什么区别？
• 3、java怎么用内部类做监视器
• 4、java多线程同步synchronized——对象监视器
• 5、java中所谓的监视器是的干什么用的

Java：Object的监视器模型上，一个对象拥有一个同步队列和等待队列是什么意思？

深入理解wait/notify/notifyAll的作用

notify: 唤醒在监视器对象上等待的单个线程，此时调用该方法的代码继续执行。

notifyAll: 唤醒在监视器对象上等待的所有线程，此时调用该方法的代码继续执行。

第一、为什么会有wait/notify/notifyAll这几个方法？

(1) wait/notify/notifyAll是为了避免轮询（尝试执行）带来的性能损失，这句话是什么意思？看下面的讲解：

为了说清道理，我们用“图书馆借书”这个经典例子来作解释。

在简单的synchrnozed 同步机制下，李四如果想借，先要去图书馆查看书有没有还回来。

李四是个心急的人，他每天都去图书馆查；而张三看书看得慢，过了半个月才把书还回来，

结果李四在这半个月里全都白跑了，浪费了不少交通车费。

而如果使用wait/notify机制，李四就不用白忙了。

他第一次去图书馆时发现书已借走，就回家静静等待(wait)；

张三把书还掉后，通知(notify)李四，李四去图书馆拿书即可。整个过程中，李四没有白跑，没浪费钱。

书 ---- 临界资源，需互斥地访问

张三，李四 ---- 两个竞争的线程

坐车去图书馆查书 ---- 轮询

车费 ---- CPU空间

等待 ---- wait

通知下一个借书者 ---- notify

也就是说，若使用简单的synchonized机制实现互斥，会导致线程主动发起轮询，若N次轮询没有成功，就产生了N次的CPU空间浪费；

如果加上了 wait/notify机制，就可以避免这些无谓的轮询，节省CPU的消耗。

(2) wait/notify/notifyAll可以控制线程执行与不执行。

第二、为什么wait/notify/notifyAll方法一定要写在synchronized里面呢？

因为第一点已经说了wait/notify/notifyAll的作用是为了避免轮询带来的性能损失，

而产生轮询的条件是多个线程对同一个资源进行操作。

第三、为什么wait/notify/notifyAll方法定义在Object类里面呢？

因为wait/notify/notifyAll必须写在synchronized里面，而synchronized的对象锁可以是任意对象，

所以wait/notify/notifyAll方法定义在Object类里面呢。

调用wait/notify/notifyAll方法的对象，必须和synchronized()的对象锁一致。

第四、

看一个wait和notify示例：

// 这个示例是不需要flag标记的：

public class Resource {

public String name;

public String sex;

public boolean flag = true;

public static void main(String[] args) {

Resource r = new Resource();

Input in = new Input(r);

Thread t1 = new Thread(in);

Output out = new Output(r);

Thread t2 = new Thread(out);

t1.start();

t2.start();

}

}

class Input implements Runnable {

Resource r;

public Input(Resource r) {

this.r = r;

}

public void run() {

int x = 0;

while (true) {

synchronized (r) {

try {

Thread.sleep(1000);

} catch (InterruptedException e1) {

e1.printStackTrace();

}

if (x == 0) {

r.name = "谢霆锋";

r.sex = "男人";

} else {

r.name = "张柏芝";

r.sex = "女人";

}

// 注意：调用notify方法后，唤醒了等待的线程。

// 但这里代码继续执行，并不是马上交给其它线程执行，除非cpu时间片结束。

r.notify();

try {

r.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

x = (x + 1) % 2;

}

}

}

class Output implements Runnable {

Resource r;

public Output(Resource r) {

this.r = r;

}

public void run() {

while (true) {

synchronized (r) {

System.out.println("--------------" + r.name + "是" + r.sex);

r.notify();

try {

r.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

}

--------------------------------------------------------------

这里要注意，再次强调：

wait/notify/notifyAll方法要放在synchronized里面，除此之外，还要非常非常注意一个重点：

调用wait/notify/notifyAll方法的对象，必须要和synchronized的对象锁是一致的。

如，以下代码是错误的：

class MyThread extends Thread {

public static Object obj = new Object();

public void run() {

synchronized(obj) {

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

this.notify();

}

}

}

--------------------------------------------------------------

java的多线程，对象锁与对象监视器有什么区别？

对象监视器用来

监视多个线程处理同一个共享数据，比如成员变量，

对于你说的那个大括号里面的对象

这个对象你可以自己定义，比如

string

str=new

stirng("11")；

object

obj=new

object()；这都可以

这个对象

主要用来

标示的

就好比是一个锁，如果你两个线程都要访问一个共享数据的话，当然

这个对象要是一样的，synchronized（对象）{

}这里的对象

必须的有，这是规范

我说的都是理解的，简易

你最好是看看这方面的视频，线程挺重要的，

java怎么用内部类做监视器

1、内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。

2、内部类可以是静态static的，也可用public，default，protected和private修饰。（而外部顶级类即类名和文件名相同的只能使用public和default）。

3、内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。 所以内部类的成员变量/方法名可以和外部类的相同。

4、内部类具有：成员内部类、局部内部类、嵌套内部类、内部类。

以下以成员内部类示例：

成员内部类，就是作为外部类的成员，可以直接使用外部类的所有成员和方法，即使是private的。同时外部类要访问内部类的所有成员变量/方法，则需要通过内部类的对象来获取。

要注意的是，成员内部类不能含有static的变量和方法。 因为成员内部类需要先创建了外部类，才能创建它自己的 ，了解这一点，就可以明白更多事情，在此省略更多的细节了。

在成员内部类要引用外部类对象时，使用outer.this来表示外部类对象；

而需要创建内部类对象，可以使用outer.inner obj = outerobj.new inner();

示例代码：

public class Outer {

public static void main(String[] args) {

Outer outer = new Outer();

Outer.Inner inner = outer. new Inner();

inner.print( "Outer.new" );

inner = outer.getInner();

inner.print( "Outer.get" );

}

public Inner getInner() {

return new Inner();

}

public class Inner {

public void print(String str) {

System.out.println(str);

}

}

}

java多线程同步synchronized——对象监视器

程 序 的 异 步 执 行 的 功 能， 所 以 在 必 要 时 必 须 还 提 ?copy; 一 种 同 步 机 制。 例 如， 你 想 两 个 线 程 通 讯 并 共 享 一 个 复 杂 的 数 据 结 构， 你 需 要 一 种 机 制 让 他 们 相 互 牵 制 并 正 确 执 行。 为 这 个 目 的，Java用 一 种 叫 监 视 器(monitor)的 机 制 实 现 了 进 程 间 的 异 步 执 行。 可 以 将 监 视 器 看 作 是 一 个 很 小 的 盒 子， 它 只 能 容 纳 一 个 线 程。 一 ?copy; 一 个 线 程 进 入 一 个 监 视 器， 所 有 其 他 线 程 必 须 等 到 第 一 个 线 程 退 出 监 视 器 后 才 能 进 入。 这 ?copy; 监 视 器 可 以 设 计 成 保 护 共 享 的 数 据 不 被 多 个 线 程 同 时 操 作。 大 多 数 多 线 程 系 统 将 这 ?copy; 监 视 器 设 计 成 对 象，Java提 ?copy; 了 一 种 更 清 晰 的 解 决 方 案。 没 有Monitor类； 每 个 对 象 通 过 将 他 们 的 成 员 函 数 定 义 成synchronized来 定 义 自 己 的 显 式 监 视 器， 一 ?copy; 一 个 线 程 执 行 在 一 个synchronized函 数 里， 其 他 任 何 线 程 都 不 能 调 用 同 一 个 对 象 的

synchronized函 数。

java中所谓的监视器是的干什么用的

简单来说，就是当你需要对某些事情的发生而作出响应的时候，你就要使用监视器来对此事进行监听！如鼠标单击时，你想做什么，就要此监视器来监听。监视器，一般叫监听器。

java监视器对象的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java菜单项加监视器、java监视器对象的信息别忘了在本站进行查找喔。