`

wait、notify 模拟queue

 
阅读更多
package com.bjsxt.base.queue;

import java.util.LinkedList;
import java.util.concurrent.atomic.AtomicInteger;

public class Myqueue {
	
	private  final  LinkedList<Object> list = new LinkedList<Object>();
	
	private AtomicInteger count = new AtomicInteger();
	
	private final int minSize = 0;
	
	private final int maxSize;
	
	public Myqueue(int size){
		this.maxSize = size;
	}
	private final Object lock = new Object();
	
	public void put(Object obj){
		synchronized (lock) {
			while(count.get() == maxSize){
				try {
					lock.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			list.add(obj);
			count.incrementAndGet();
			System.out.println("新加入的元素:"+obj);
			System.out.println("剩余:"+count.get());
			lock.notify();
		}
	}
	public Object take(){
		Object ret = null;
		synchronized (lock) {
			while(count.get() == this.minSize){
				try {
					lock.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			ret = list.removeFirst();
			count.decrementAndGet();
			lock.notify();
			System.out.println("拿元素:"+ret);
			System.out.println("剩余:"+count.get());
		}
		return ret;
	}
	public int getSize(){
		return count.get();
	}
	
	public static void main(String[] args) {
		final Myqueue mq = new Myqueue(5);
		mq.put("a");
		mq.put("b");
		mq.put("c");
		mq.put("d");
		mq.put("e");
		System.out.println("当前容器长度 "+mq.getSize());
		
		
		new Thread(new Runnable(){
			@Override
			public void run() {
				mq.put("1");
				mq.put("2");
			}
		}).start();
	   try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	   new Thread(new Runnable(){
			@Override
			public void run() {
				for(;;){
				   try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					mq.take();
				}
				
			}
		}).start();
	   try {
		Thread.sleep(20000);
	} catch (InterruptedException e1) {
		// TODO Auto-generated catch block
		e1.printStackTrace();
	}
	   new Thread(new Runnable(){
			@Override
			public void run() {
				mq.put("10");
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				mq.put("20");
			}
		}).start();
	   try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

}

 

分享到:
评论

相关推荐

    java多线程模拟队列实现排队叫号

    同样,在`ServiceThread`中,我们可能使用`Object.wait()`和`Object.notify()`或者`Condition`来实现线程间的同步,确保每次只有一个客户正在接受服务。 ```java public class CustomerThread extends Thread { ...

    Queue-Simulation_java_learnvwf_源码.zip

    Java的`Thread`类和同步机制(如`synchronized`关键字、`wait()`、`notify()`方法)可以确保在多线程环境下的数据一致性。同时,`BlockingQueue`接口(如`LinkedBlockingQueue`、`ArrayBlockingQueue`等实现)提供了...

    java操作系统生产者消费者问题模拟

    在计算机科学领域,生产者-消费者问题是多线程编程中的一种经典同步问题。...通过这种方式,我们可以在不引入复杂的同步机制(如`synchronized`关键字和`wait()`、`notify()`方法)的情况下,实现高效的多线程协作。

    ProducerConsumer(生产者消费者问题的单线程模拟)

    在单线程模拟中,我们通常会用到线程同步机制来确保数据的一致性和正确性。 在C++编程中,我们可以利用标准模板库(STL)中的`std::queue`作为共享数据结构,代表缓冲区。生产者将产品放入队列,消费者则从队列中取出...

    java模拟进程调度算法和进程控制

    在Java中,虽然没有直接的原生支持来模拟这些操作,但可以使用并发和多线程类库(如`Thread`和`ExecutorService`)来实现类似的机制,例如通过`wait()`和`notify()`方法模拟阻塞和唤醒,通过`Thread.sleep()`模拟挂...

    SCJP考试模拟机题库

    2. 线程同步:理解synchronized关键字,以及wait()、notify()、notifyAll()方法的使用。 3. 线程池:了解ExecutorService和Future接口,以及ThreadPoolExecutor的使用。 七、IO与NIO 文件操作和输入输出流在SCJP中...

    java二级考试模拟题目

    6. **多线程**:Java提供了丰富的多线程支持,考生应理解线程的创建方式(Thread类和Runnable接口),线程同步(synchronized关键字、wait()、notify()、notifyAll()方法)、线程池(ExecutorService、...

    SCJP模拟考题附答案

    - **线程同步**:掌握synchronized关键字,以及wait(), notify(), notifyAll()方法在并发控制中的应用。 - **线程池**:了解ExecutorService和ThreadPoolExecutor,以及它们在处理大量并发任务时的优势。 8. **...

    Python中使用Queue和Condition进行线程同步的方法

    `Condition`对象基于锁(`Lock`或`RLock`),提供`wait()`、`notify()`和`notifyAll()`方法。 - `acquire()`: 获取锁,使线程进入临界区。 - `release()`: 释放锁,让其他等待的线程可以获取锁。 - `wait()`: 当...

    JAVA认证-scjp模拟试题

    7. **多线程**:线程的创建与同步,synchronized关键字,wait()、notify()、notifyAll()方法,Thread类和Runnable接口的区别。 8. **输入/输出流**:I/O流的分类(字节流和字符流),File类,Reader和Writer,...

    操作系统生产者与消费者问题Java简单模拟实现

    此外,`wait()`和`notify()`方法可能被用来在生产者和消费者之间进行更精细的控制。当生产者发现队列已满,它会调用`wait()`,将自身置于等待状态,同时释放锁。消费者取走元素后,如果发现队列为空,也会调用`wait...

    Java线程间的通信----生产者消费者模型

    - `wait()`和`notify()`/`notifyAll()`:这两个方法位于`Object`类中,用于线程间的通信。生产者线程在生产完产品后调用`notify()`或`notifyAll()`唤醒消费者线程,消费者线程在消费完产品后调用`wait()`进入等待...

    ocjp考试模拟题

    4. **多线程**:Java提供了强大的多线程支持,包括Thread类、Runnable接口、同步机制(synchronized关键字、wait()、notify()和notifyAll()方法)、线程池(ExecutorService)等。 5. **输入/输出流**:Java I/O...

    JAVA认证-SCJP模拟试题(DOC 79页).rar

    了解synchronized关键字、线程同步机制、wait/notify机制以及ExecutorService和Future接口。 11. **输入输出流**:FileInputStream、FileOutputStream、BufferedReader、BufferedWriter等类的使用,以及File类和I/O...

    java模拟试题

    7. **多线程**:线程的创建方式(继承Thread类和实现Runnable接口),线程同步机制(synchronized关键字,wait()、notify()和notifyAll()方法),以及线程池的使用。 8. **反射机制**:Class类的使用,动态创建对象...

    SCJP考试经验和模拟题

    14. **多线程**:理解并发编程的基本概念,如线程的创建、同步和通信(synchronized关键字,wait(),notify(),Thread.join())。 15. **反射API**:学习如何使用反射来动态地访问和修改类、接口、字段和方法。 16...

    java程序员认证模拟题及详细分析

    2. 线程同步:理解synchronized关键字的作用,以及wait(), notify(), notifyAll()方法的使用。 3. 线程池:了解ExecutorService和ThreadPoolExecutor,理解线程池的工作原理。 六、反射 1. 获取类信息:使用Class...

    【计算机知识】Java多线程之生产者与消费者.doc

    通过`synchronized`关键字和`wait()`、`notify()`方法,我们可以有效地控制多线程间的协作,保证数据的一致性和正确性。这种模式在实际开发中有着广泛的应用,尤其是在处理并发任务和数据流时。

    线程实现生产者消费者问题

    需要注意的是,为了模拟多个生产者和消费者,可以使用循环来重复生产和消费过程,或者在达到特定条件后退出。 以下是简化版的生产者和消费者线程实现: ```cpp void producer(int id) { while (true) { std::...

Global site tag (gtag.js) - Google Analytics