多线程-wait(针对OBJECT对象锁的方式)

对象锁,是 使用一个object 对象,将这个对象供多个线程共享使用,然后再线程中,对这个对象加锁。

直接看代码

package com.luoy.Thread.wait;

public class ObjectWait2{

   public static void main(String[] args)
         throws InterruptedException{

      Object b = new Object();
      Object c = new Object();

     new Thread(new BuyFood(b, c)).start();
     Thread.sleep(1000);
     new Thread(new CookFood(b, c)).start();
   }
}

class BuyFood
      implements
         Runnable{

   private Object block;

   private Object clock;

   public BuyFood(Object block,
               Object clock){
      this.block = block;
      this.clock = clock;
   }

   @Override
   public void run(){

      for(int i = 0; i < 10; i++){

         synchronized(clock){
            //得到买的锁
            synchronized(block){
               p("买萝卜"+i);
               block.notify();
            }
            try{
               clock.wait();
            }catch(InterruptedException e){
               // TODO Auto-generated catch block
               e.printStackTrace();
            }

         }

         try{
            Thread.sleep(1000);
         }catch(InterruptedException e){
            // TODO Auto-generated catch block
            e.printStackTrace();
         }
      }

   }

   private void p(String s){
      System.out.println(s);
   }

}

class CookFood
      implements
         Runnable{

   private Object block;

   private Object clock;

   public CookFood(Object block,
               Object clock){
      this.block = block;
      this.clock = clock;
   }

   @Override
   public void run(){

      for(int i = 0; i < 10; i++){

      synchronized(block){
         //得到买的锁
         synchronized(clock){
            p("煮萝卜"+i);
               clock.notify();
         }
            try{
               block.wait();
            }catch(InterruptedException e){
               // TODO Auto-generated catch block
               e.printStackTrace();
            }
      }
      }

   }

   private void p(String s){
      System.out.println(s);
   }

}

结果

买萝卜0
煮萝卜0
买萝卜1
煮萝卜1
买萝卜2
煮萝卜2
买萝卜3
煮萝卜3
买萝卜4
煮萝卜4
买萝卜5
煮萝卜5
买萝卜6
煮萝卜6
买萝卜7
煮萝卜7
买萝卜8
煮萝卜8
买萝卜9
煮萝卜9
时间: 2024-10-12 22:49:53

多线程-wait(针对OBJECT对象锁的方式)的相关文章

Java Object 对象创建的方式 [ 转载 ]

Java Object 对象创建的方式 [ 转载 ] @author http://blog.csdn.net/mhmyqn/article/details/7943411 显式创建 有4种显式地创建对象的方式: 1.构造器:用new语句创建对象,这是最常用的创建对象的方式. 2.反射:运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法. 3.克隆:调用对象的clone()方法. 4.序列化:运用反

java同步机制对象锁使用方式比较

class Sync { private byte[] lock = new byte[0]; public void sync() throws InterruptedException { synchronized (lock) { runThread(); } } public void thisSync() throws InterruptedException { synchronized (this) { runThread(); } } public synchronized st

Java对象锁和类锁全面解析(多线程synchronized关键字)

最近工作有用到一些多线程的东西,之前吧,有用到synchronized同步块,不过是别人怎么用就跟着用,并没有搞清楚锁的概念.最近也是遇到一些问题,不搞清楚锁的概念,很容易碰壁,甚至有些时候自己连用没用对都不知道. 今天把一些疑惑都解开了,写篇文章分享给大家,文章还算比较全面.当然可能有小宝鸽理解得不够深入透彻的地方,如果说得不正确还望指出. 看之前有必要跟某些猿友说一下,如果看一遍没有看明白呢,也没关系,当是了解一下,等真正使用到了,再回头看. 本文主要是将synchronized关键字用法作

Java多线程 同步 对象锁

多线程.同步: https://www.cnblogs.com/GarfieldEr007/p/5746362.html Java对象锁和类锁全面解析(多线程synchronized关键字): http://blog.csdn.net/u013142781/article/details/51697672 Java Object对象中的wait,notify,notifyAll通俗理解 http://blog.csdn.net/vk5176891/article/details/53945677

从头认识多线程-2.2 synchronized持有对象锁与类锁的相同点

这一章节我们来讨论一下synchronized持有对象锁与类锁的相同点. 1.当所有方法都不使用同步的时候 代码清单 package com.ray.deepintothread.ch02.topic_2; public class SynchInstance1 { public static void main(String[] args) throws InterruptedException { MyTestObjectOne myTestObjectOne = new MyTestObj

浅析多线程的对象锁和Class锁

一.前言 本来想在另外一篇文章说的,发现可能篇幅有点大,所以还是另开一篇博文来说好了.知识参考<Java多线程编程核心技术>,评价下这本书吧——大量的代码,简单的说明,真像在看博客.不过这本书浅显易懂,篇幅也不长,一口气看个几十页,再照着demo敲敲代码,简直不要太爽..哈哈 二.概念 对象锁:顾名思义,就是这个锁属于这个类的对象实例,可以通过为类中的非静态方法加synchronized关键字 或者使用 synchronized(this) 代码块,为程序加对象锁. Class锁:顾名思义,就

Python36 1.joinablequeue 2.线程理论 3.多线程对比多进程 4.线程的使用方式 4.1.产生 线程的两种方式 4.2.守护线程 4.3.线程安全问题 4.3.1.互斥锁 4.3.2.死锁 4.3.3.可重入锁 4.3.4.信号量

复习1.守护进程2.互斥锁(解决数据错乱的方法)3.IPC(进程间通讯)4.生产者与消费者模型 详解:1.守护进程 一个进程可以设为另一个进程的守护进程 特点:被守护的进程结束时,守护进程也会随之结束 本质:父进程交给子进程一个任务,然而父进程 先于子进程结束了,子进程的任务也就没有必要 继续执行了 格式:开始前加 p.daemon=True 2.互斥锁(解决数据错乱的方法)方法一:互斥锁 互斥 互相排斥 锁的本质:一个标志 标志的两个状态: 1.锁定 2.未锁定 什么时候用? 当多个进程要操作

从头认识多线程-2.3 synchronized持有对象锁与类锁的不同点

这一章节我们来讨论游戏,synchronized持有对象锁与类锁的不同点-两种锁是并行的东西,没有交集. 1.同步持有对象锁或者类锁 package com.ray.deepintothread.ch02.topic_3; public class SynchInstance5 { public static void main(String[] args) throws InterruptedException { MyTestObjectFive myTestObjectFive = new

001JAVA多线程实例对象锁与类锁

package com.skcc.mthread; public class MuiltThread { private static int num = 0; public MuiltThread() { // TODO Auto-generated constructor stub } /**** * synchronized void printNum(String tag) 代表 synchronized锁定的MuiltThread实例对象锁(m1,m2两者间互不影响) * static