精华内容
下载资源
问答
  • 关注 Java 线程池的任务队列长度

    千次阅读 2013-10-21 17:18:28
    Java 5.0 就开始自带线程池的实现,其中固定大小的线程池,对普通使用还是很好用的。就是 Executors.newFixedThreadPool ,指需要指定一个大小数目就可以。相对于其他几种方式,易于实现高效稳定的服务器。   ...

     

    Java 5.0 就开始自带线程池的实现,其中固定大小的线程池,对普通使用还是很好用的。就是 Executors.newFixedThreadPool ,指需要指定一个大小数目就可以。相对于其他几种方式,易于实现高效稳定的服务器。

     

    但是好用归好用,一些需要非常细心的问题,还是需要关注的,尤其是高并发场景,7*24不间断运行场景下。本文就是把这些地方记录下来,在设计和实现时,在这些问题上务必不能马虎,因为这关系到稳定性和效率,且不易通过测试来排查。

     

    (1)实现:

     

    几种线程池,都是通过  ThreadPoolExecutor 来实现的,如下:

     

    1. ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler)  

     

     

    newFixedThreadPool :

     

      public static ExecutorService newFixedThreadPool(int paramInt)
      {
        return new ThreadPoolExecutor(paramInt, paramInt, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
      }
    

     

    而 LinkedBlockingQueue的实现:

     

      public LinkedBlockingQueue()
      {
        this(2147483647);
      }

     

    这个默认的构造函数,实际上是有一些问题的(实际是构造了一个大小为 Integer.MAX_VALUE的任务队列)。

     

    (2)问题

    我们设想一个场景,客户端/服务器工作模式,请求来得很快,服务器端accept之后,将Socket放到了任务队列中,读请求处理,并发送响应。客户端连接来得很快,但处理没有那么快(例如需要IO或大量数学运算),所以来了之后就都排在队列里。一直到2147483647。

     

    但是实际上,如果一个新的任务排在第100甚至1000、10000,客户端都可以等待,但是如果排到了 1000,000,客户端还会等待着吗?就像你如果去银行办业务,眼看排队都排到街上了,今天肯定轮不到了,你还会继续等吗?

     

    换成计算机的设计语言,客户端连接,按照约定俗成,都是有超时的,开始提交了请求自然会等待,一定时间内得不到响应就超时进入异常处理流程了,那么,服务器队列里那个Socket还有什么意义呢?

     

    (3)结论

     

    所以说,在设计时,队列的长度是一定要用心设计和考虑的,除了在Demo和简单测试一下的程序里,不要轻易而简单的使用newFixedThreadPool ,要想清楚它的问题,在使用时使用其它方式避免。

     

    一般情况下,队列的大小遵循下面的公事:

     

     queSize <= ClientTimeOut(秒) * TPS

     

    队列大小 小于等于 客户端超时 * 每秒处理的交易数

     

    当然,这些数据都是估算,另外,也取决于你做的东西,对于客户端超时早就走了,服务器端还得处理这种情况是一种什么态度和需求。

     

     

     

     

     

     

     

     

     

    展开全文
  • Java阻塞队列

    2020-08-16 09:57:50
    2)支持阻塞的移除方法:意思是在队列为空时,获取元素的线程会等待队列变为非空 阻塞队列常用于生产者和消费者的场景,生产者是向队列里添加元素的线程,消费者是从队列里取元素的线程。阻塞队列就是生产者用来...

    一、背景

    阻塞队列(BlockingQueue)是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法

    1)支持阻塞的插入方法:意思是当队列满时,队列会阻塞插入元素的线程,直到队列不满。

    2)支持阻塞的移除方法:意思是在队列为空时,获取元素的线程会等待队列变为非空

    阻塞队列常用于生产者和消费者的场景,生产者是向队列里添加元素的线程,消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器。

    在阻塞队列不可用时,这两个附加操作提供了4种处理方式

    抛出异常:是指当阻塞队列满时候,再往队列里插入元素,会抛出 IllegalStateException("Queue full") 异常。当队列为空时,从队列里获取元素时会抛出 NoSuchElementException 异常 。

    返回特殊值:插入方法会返回是否成功,成功则返回 true。移除方法,则是从队列里拿出一个元素,如果没有则返回 null

    一直阻塞:当阻塞队列满时,如果生产者线程往队列里 put 元素,队列会一直阻塞生产者线程,直到拿到数据,或者响应中断退出。当队列空时,消费者线程试图从队列里 take 元素,队列也会阻塞消费者线程,直到队列可用。

    超时退出:当阻塞队列满时,队列会阻塞生产者线程一段时间,如果超过一定的时间,生产者线程就会退出。

    如果是无界阻塞队列,队列不可能会出现满的情况,所以使用put或offer方法永远不会被阻塞,而且使用offer方法时,该方法永远返回true

    二、阻塞队列

    JDK7 提供了 7 个阻塞队列。分别是

    • ArrayBlockingQueue:是一个用数组实现的有界阻塞队列,此队列按照先进先出(FIFO)的原则对元素进行排序。支持公平锁和非公平锁。【注:每一个线程在获取锁的时候可能都会排队等待,如果在等待时间上,先获取锁的线程的请求一定先被满足,那么这个锁就是公平的。反之,这个锁就是不公平的。公平的获取锁,也就是当前等待时间最长的线程先获取锁】

    • LinkedBlockingQueue:一个由链表结构组成的有界队列,此队列的长度为Integer.MAX_VALUE。此队列按照先进先出的顺序进行排序。
    • PriorityBlockingQueue: 一个支持线程优先级排序的无界队列,默认自然序进行排序,也可以自定义实现compareTo()方法来指定元素排序规则,不能保证同优先级元素的顺序。
    • DelayQueue: 一个实现PriorityBlockingQueue实现延迟获取的无界队列,在创建元素时,可以指定多久才能从队列中获取当前元素。只有延时期满后才能从队列中获取元素。(DelayQueue可以运用在以下应用场景:1.缓存系统的设计:可以用DelayQueue保存缓存元素的有效期,使用一个线程循环查询DelayQueue,一旦能从DelayQueue中获取元素时,表示缓存有效期到了。2.定时任务调度。使用DelayQueue保存当天将会执行的任务和执行时间,一旦从DelayQueue中获取到任务就开始执行,从比如TimerQueue就是使用DelayQueue实现的。)
    • SynchronousQueue: 一个不存储元素的阻塞队列,每一个put操作必须等待take操作,否则不能添加元素。支持公平锁和非公平锁。SynchronousQueue的一个使用场景是在线程池里。Executors.newCachedThreadPool()就使用了SynchronousQueue,这个线程池根据需要(新任务到来时)创建新的线程,如果有空闲线程则会重复使用,线程空闲了60秒后会被回收。
    • LinkedTransferQueue: 一个由链表结构组成的无界阻塞队列,相当于其它队列,LinkedTransferQueue队列多了transfer和tryTransfer方法。
    • LinkedBlockingDeque: 一个由链表结构组成的双向阻塞队列。队列头部和尾部都可以添加和移除元素,多线程并发时,可以将锁的竞争最多降到一半。

    ArrayBlockingQueue 

    ArrayBlockingQueue是一个用数组实现的有界阻塞队列。此队列按照先进先出(FIFO)的原则对元素进行排序

    items:一个Object的数组

    tackIndex:出队列的下标

    putIndex:入队列的下标

    count:队列中元素的数量

    ArrayBlockingQueue 是一个用数组实现的有界阻塞队列。此队列按照先进先出(FIFO)的原则对元素进行排序。默认情况下不保证访问者公平的访问队列,所谓公平访问队列是指阻塞的所有生产者线程或消费者线程,当队列可用时,可以按照阻塞的先后顺序访问队列,即先阻塞的生产者线程,可以先往队列里插入元素,先阻塞的消费者线程,可以先从队列里获取元素。通常情况下为了保证公平性会降低吞吐量。我们可以使用以下代码创建一个公平的阻塞队列

    ArrayBlockingQueue fairQueue = new ArrayBlockingQueue(1000,true);

    查看ArrayBlockingQueue 的构造函数

    设置ReentrantLock的锁模式为公平锁

    LinkedBlockingQueue 

    LinkedBlockingQueue 是一个用链表实现的有界阻塞队列。此队列的默认和最大长度为 Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行排序

    ArrayBlockingQueue 和LinkedBlockingQueue区别

    1:底层实现不同

    ArrayBlockingQueue 底层使用数组来维护队列,

    LinkedBlockingQueue 底层使用链表来维护队列,在添加和删除队列中的元素的时候,会创建和销毁节点对象,在高并发和大量数据的时候,GC压力很大。

    2:锁的方式不同

    ArrayBlockingQueue 获取数据和添加数据都是使用同一个锁对象,这样添加和获取就不是一个并发的过程,不过,在ArrayBlockingQueue 中使用Condition的等待/通知机制,这样使得ArrayBlockingQueue的数据写入和获取操作已经足够轻巧,以至于引入独立的锁机制,除了给代码带来额外的复杂性外,其在性能上完全占不到任何便宜

    LinkedBlockingQueue  获取数据和添加数据使用不同的锁对象。

    PriorityBlockingQueue

    PriorityBlockingQueue是一个支持优先级的无界阻塞队列。默认情况下元素采取自然顺序升序排列。继承Comparable类实现compareTo()方法来指定元素排序规则,或者初始化PriorityBlockingQueue时,指定构造参数Comparator来对元素进行排序。需要注意的是不能保证同优先级元素的顺序。

    例子 学生实体类存入PriorityBlockingQueue 队列按照年龄升序排序

    结果:

    DelayQueue

    DelayQueue是一个支持延时获取元素的无界阻塞队列。队列使用PriorityQueue来实现。队列中的元素必须实现Delayed接口,在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素

    DelayQueue非常有用,可以将DelayQueue运用在以下应用场景。

    ·缓存系统的设计:可以用DelayQueue保存缓存元素的有效期,使用一个线程循环查询DelayQueue,一旦能从DelayQueue中获取元素时,表示缓存有效期到了。

    ·定时任务调度:使用DelayQueue保存当天将会执行的任务和执行时间,一旦从DelayQueue中获取到任务就开始执行,比如TimerQueue就是使用DelayQueue实现的

    实现DelayQueue的三个步骤

    第一步:继承Delayed接口

    第二步:实现getDelay(TimeUnit unit),该方法返回当前元素还需要延时多长时间,单位是纳秒

    第三步:实现compareTo方法来指定元素的顺序

    例子:使用Task类给定延迟时间,继承Delayed,并重写getDelay()方法,然后重写compareTo()方法来规定先到期的Task对象先出队列

    结果

    SynchronousQueue

    SynchronousQueue是一个不存储元素的阻塞队列。每一个put操作必须等待一个take操作,否则不能继续添加元素。它支持公平访问队列。默认情况下线程采用非公平性策略访问队列。使用以下构造方法可以创建公平性访问的SynchronousQueue,如果设置为true,则等待的线程会采用先进先出的顺序访问队列

    SynchronousQueue<E> queue = new SynchronousQueue<E>(true);

    SynchronousQueue可以看成是一个传球手,负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素,非常适合传递性场景。SynchronousQueue的吞吐量高于LinkedBlockingQueue和ArrayBlockingQueue。

    例子 

    结果

    LinkedTransferQueue

    LinkedTransferQueue是一个由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列,LinkedTransferQueue多了tryTransfer和transfer方法

    (1)transfer方法

    如果当前有消费者正在等待接收元素(消费者使用take()方法或带时间限制的poll()方法时),transfer方法可以把生产者传入的元素立刻transfer(传输)给消费者。如果没有消费者在等待接收元素,transfer方法会将元素存放在队列的tail节点,并等到该元素被消费者消费了才返回

    (2)tryTransfer方法

    tryTransfer方法是用来试探生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素,则返回false。和transfer方法的区别是tryTransfer方法无论消费者是否接收,方法立即返回,而transfer方法是必须等到消费者消费了才返回。

    对于带有时间限制的tryTransfer(E e,long timeout,TimeUnit unit)方法,试图把生产者传入的元素直接传给消费者,但是如果没有消费者消费该元素则等待指定的时间再返回,如果超时还没消费元素,则返回false,如果在超时时间内消费了元素,则返回true

    LinkedBlockingDeque

    LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列。所谓双向队列指的是可以从队列的两端插入和移出元素。双向队列因为多了一个操作队列的入口,在多线程同时入队时,也就减少了一半的竞争。相比其他的阻塞队列,LinkedBlockingDeque多了addFirst、addLast、offerFirst、offerLast、peekFirst和peekLast等方法,以First单词结尾的方法,表示插入、获取(peek)或移除双端队列的第一个元素。以Last单词结尾的方法,表示插入、获取或移除双端队列的最后一个元素。另外,插入方法add等同于addLast,移除方法remove等效于removeFirst。但是take方法却等同于takeFirst,不知道是不是JDK的bug,使用时还是用带有First和Last后缀的方法更清楚。在初始化LinkedBlockingDeque时可以设置容量防止其过度膨胀。另外,双向阻塞队列可以运用在“工作窃取”模式中。

    阻塞的实现

    ReentranLock + Condition 实现队列的阻塞,ReentranLock 是锁,Condition是条件状态,通过等待/通知机制,来实现线程之间的通信。

    ReentranLock + Condition的等待/通知机制和Object的wait()与notify()是类似的,通过synchronized,在锁中使用wait()与notify()达到线程之间通信,在ReentranLock 的lock()和unlock()之间通过类似的await()和signal()达到线程之间的通信。

    在阻塞队列中A调用put()方法的时候,如果队列已满,则A线程挂起,等待恢复,如果B线程调用take()后,消耗一个队列元素后,会通知put()方法中挂起的A线程,因为这个时候B线程已经消耗一个元素可以在向队列中添加元素。相反如果队列一空 B线程调用take()方法会阻塞,当A线程调用put()调用后通知take()方法中的B线程,有元素可以获取。这就是阻塞的实现过程。

    下面查看ArrayBlockingQueue 源码来分析这一实现过程

    ArrayBlockingQueue的成员变量

    lock 是锁   notEmpty和notFull是表示不为空和不为满的Condition状态

    构造函数初始化,默认使用非公平锁

    查看put()方法

    enqueue()

    查看take()方法

    dequeue()

     转自:https://www.jianshu.com/p/32665a52eba1

    展开全文
  • Java)固定长度队列的实现

    万次阅读 2017-07-07 13:40:28
        import java.util.Collection;  import java.util.Iterator;  ...import java.util.LinkedList;...import java.util.Queue;... * 固定长度队列   * @author gary   *   */ 

    1. package com.gary.util;  
    2.   
    3. import java.util.Collection;  
    4. import java.util.Iterator;  
    5. import java.util.LinkedList;  
    6. import java.util.Queue;  
    7.   
    8. /** 
    9.  * 固定长度队列 
    10.  * @author gary 
    11.  * 
    12.  */  
    13. public class LimitQueue<E> implements Queue<E>{  
    14.     //队列长度  
    15.     private int limit;  
    16.       
    17.     Queue<E> queue = new LinkedList<E>();  
    18.       
    19.     public LimitQueue(int limit){  
    20.         this.limit = limit;  
    21.     }  
    22.       
    23.     /** 
    24.      * 入队 
    25.      * @param e 
    26.      */  
    27.     @Override  
    28.     public boolean offer(E e){  
    29.         if(queue.size() >= limit){  
    30.             //如果超出长度,入队时,先出队  
    31.             queue.poll();  
    32.         }  
    33.         return queue.offer(e);  
    34.     }  
    35.       
    36.     /** 
    37.      * 出队 
    38.      * @return 
    39.      */  
    40.     @Override  
    41.     public E poll() {  
    42.         return queue.poll();  
    43.     }  
    44.       
    45.     /** 
    46.      * 获取队列 
    47.      * @return 
    48.      */  
    49.     public Queue<E> getQueue(){  
    50.         return queue;  
    51.     }  
    52.       
    53.     /** 
    54.      * 获取限制大小 
    55.      * @return 
    56.      */  
    57.     public int getLimit(){  
    58.         return limit;  
    59.     }  
    60.   
    61.     @Override  
    62.     public boolean add(E e) {  
    63.         return queue.add(e);  
    64.     }  
    65.   
    66.     @Override  
    67.     public E element() {  
    68.         return queue.element();  
    69.     }  
    70.   
    71.     @Override  
    72.     public E peek() {  
    73.         return queue.peek();  
    74.     }  
    75.   
    76.     @Override  
    77.     public boolean isEmpty() {  
    78.         return queue.size() == 0 ? true : false;  
    79.     }  
    80.   
    81.     @Override  
    82.     public int size() {  
    83.         return queue.size();  
    84.     }  
    85.   
    86.     @Override  
    87.     public E remove() {  
    88.         return queue.remove();  
    89.     }  
    90.   
    91.     @Override  
    92.     public boolean addAll(Collection<? extends E> c) {  
    93.         return queue.addAll(c);  
    94.     }  
    95.   
    96.     @Override  
    97.     public void clear() {  
    98.         queue.clear();  
    99.     }  
    100.   
    101.     @Override  
    102.     public boolean contains(Object o) {  
    103.         return queue.contains(o);  
    104.     }  
    105.   
    106.     @Override  
    107.     public boolean containsAll(Collection<?> c) {  
    108.         return queue.containsAll(c);  
    109.     }  
    110.   
    111.     @Override  
    112.     public Iterator<E> iterator() {  
    113.         return queue.iterator();  
    114.     }  
    115.   
    116.     @Override  
    117.     public boolean remove(Object o) {  
    118.         return queue.remove(o);  
    119.     }  
    120.   
    121.     @Override  
    122.     public boolean removeAll(Collection<?> c) {  
    123.         return queue.removeAll(c);  
    124.     }  
    125.   
    126.     @Override  
    127.     public boolean retainAll(Collection<?> c) {  
    128.         return queue.retainAll(c);  
    129.     }  
    130.   
    131.     @Override  
    132.     public Object[] toArray() {  
    133.         return queue.toArray();  
    134.     }  
    135.   
    136.     @Override  
    137.     public <T> T[] toArray(T[] a) {  
    138.         return queue.toArray(a);  
    139.     }  
    140.   
    141. }  

    1. package com.gary.test;  
    2.   
    3. import com.gary.util.LimitQueue;  
    4.   
    5. public class TestQueue {  
    6.     public static void main(String[] args) {  
    7.         LimitQueue<String> lqueue = new LimitQueue<String>(3);  
    8.           
    9.         lqueue.offer("1");  
    10.         lqueue.offer("2");  
    11.         lqueue.offer("3");  
    12.         lqueue.offer("4");  
    13.           
    14.         //1因超出队列大小限制已自动出队,输出结果为2,3,4  
    15.         for (String string : lqueue.getQueue()) {  
    16.             System.out.println(string);  
    17.         }  
    18.     }  
    19. }  

    原文链接:http://gary0416.iteye.com/blog/1074762

    展开全文
  • java数组队列

    2018-09-06 16:37:20
    下面是我对java数组队列的理解。 什么是数组队列? 数组队列就是利用数组存储数据的属性来改变它只有固定长度的局限性,增加了一些删除,添加数据等功能,增加了其灵活性; 数组队列的实现 数组队列实现分为两...

    学习不久,理解不深。有错误之处还请指正。下面是我对java数组队列的理解。

    什么是数组队列?

    数组队列就是利用数组存储数据的属性来改变它只有固定长度的局限性,增加了一些删除,添加数据等功能,增加了其灵活性;

    数组队列的实现

    数组队列实现分为两部分:

    1.数组队列接口

    在数组队列接口中需要定义一些抽象方法,例如删除数据,添加数据,获取数据等方法

    若你想存储多种类型的数据你可以使用泛型,泛型可以用来指任何类型的一种数据。下面的代码使用泛型编写的,以便于添加存储自己想要的类型数据。

    接下来创建一个接口List<E>类,用来删除数据,添加数据,获取数据等等,下面是代码。

    public interface List<E> {
    public void add(E e);//向队列末尾添加一个元素
    public boolean add(int index,E e);//向指定位置添加一个元素,添加成功返回true,添加失败返回false;
    public E getE(int index);//获取指定位置的元素
    public E remove(int index);//删除指位置的元素
    public boolean remove(E e);//删除元素
    public boolean update(int index,E e);//更新指定位置的元素
    public boolean update(E e,E newValue);//更新某一个元素
    public boolean removeall();//移除所有元素
    public int size();//获取数组队列中元素个数的总数
    }

     

    2.数组队列类

    在数组队列类中继承数组队列接口,然后要定义两个重要的属性,分别是数组长度length元素个数size;然后在重写接口中的所有方法就可以了,关键是写好添加,删除等方法;下面的代码使用泛型编写的,以便于添加存储自己想要的类型数据。

    下面是数组队列类myArraysList<E>的代码

    public class myArraysList<E> implements List<E>{
    	private static int size=0;//定义数组队列中元素个数的初始值,为了在数组队列类中测试下面的方法是否正确,所以设置成静态
    	private static int length=1;//记录数组初始长度,为了在数组队列类中测试下面的方法是否正确,所以设置成静态
    	Object [] Array;//声明一个数组变量
    	public myArraysList(int length){
    		this.length=length;
    		Array=new Object[length];//定义数组长度为length
    	}
    	@Override
    	public void add(E e) {//向队列末尾添加一个元素
    		// TODO Auto-generated method stub
    		if(size<length){//元素个数小于数组长度就添加
    			Array[size]=e;
    			
    		}
    		else{
    			Object[] Array1=new Object[length*2];//Array1指定义的一个新的数组
    			for(int i=0;i<length;i++){
    				Array1[i]=Array[i];
    			}
    			Array1[size]=e;
    			Array=Array1;
    			length=Array1.length;
    		}
    		size++;
    	}
    
    	@Override
    	public boolean add(int index, E e) {//向指定位置添加一个元素,添加成功返回true,添加失败返回false;
    		// TODO Auto-generated method stub
    		if(index<0||index>=size){
    			System.out.println("超过数组的size就不能添加");
    			return false;
    		}
    		else{
    			Object []Array1=new Object[size+1];//Array1指定义的一个新的数组
    			for(int i=0;i<index;i++){
    				Array1[i]=Array[i];
    			}
    			Array1[index]=e;//把要添加的元素加入指定位置
    			for(int i=index;i<size;i++){
    				Array1[i+1]=Array[i];
    			}
    			Array=Array1;
    			length=Array1.length;
    			size++;
    		return true;
    		}
    		
    	}
    
    	@SuppressWarnings("unchecked")
    	@Override
    	public E getE(int index) {//获取指定位置的元素
    		// TODO Auto-generated method stub
    		if(index<0||index>=size){
    			return null;
    		}
    		else{
    		return (E)Array[index];
    		}
    	}
    
    	@Override
    	public E remove(int index) {//删除指位置的元素
    		// TODO Auto-generated method stub
    		if(index<0||index>=size){
    			System.out.println("超过数组的size就不能删除");
    		}
    		else{
    			Array[index]=null;
    			for(int i=index;i<size-1;i++){
    				Array[i]=Array[i+1];
    			}
    			size--;
    		}
    		return null;
    	}
    
    	@Override
    	public boolean remove(E e) {//删除元素
    		// TODO Auto-generated method stub
    		for(int i=0;i<size;i++){
    			if(Array[i]==e){
    				Array[i]=null;
    				for(int j=i;j<size-1;j++){
    					Array[j]=Array[j+1];
    				}
    				size--;
    			}
    		}
    		return true;
    	}
    
    	@Override
    	public boolean update(int index, E e) {//更新指定位置的元素
    		// TODO Auto-generated method stub
    		if(index>=0&&index<size){
    			Array[index]=e;
    			}	
    		return true;
    	}
    
    	@Override
    	public boolean update(E e, E newValue) {//更新某一个元素
    		// TODO Auto-generated method stub
    		for(int i=0;i<size;i++){
    			if(Array[i]==e){
    				Array[i]=newValue;
    			}
    		}
    		return true;
    	}
    
    	@Override
    	public boolean removeall() {//移除所有元素
    		// TODO Auto-generated method stub
    		Object []Array1=new Object[0];
    		Array=Array1;
    		if(Array.length ==0)
    			return true;
    		else
    			return false;
    	}
    
    	@Override
    	public int size() {//获取数组队列中元素个数的总数
    		// TODO Auto-generated method stub
    		return size;
    	}
    	public static void main(String [] args){//这里主函数是为了测试上式方法的正确性
    		myArraysList<String> mylist=new myArraysList<String>(length);//创建数组队列对象myArraysList
    		mylist.add("wo");
    		mylist.add("xihuan");
    		mylist.add("ni");
    		mylist.add(2, "you");
    		
    		for(int i=0;i<size;i++){
    			Object e=mylist.getE(i);
    			System.out.println("得到的元素是:"+e);
    		}
    		mylist.remove("you");
    		mylist.update(2, "i");
    		//mylist.removeall();
    		for(int i=0;i<size;i++){
    			Object e=mylist.getE(i);
    			System.out.println("得到的元素是:"+e);
    		}
    	}
    }

    参考:https://blog.csdn.net/weixin_42621338/article/details/82080167

     

     

     

     

     

    展开全文
  • 队列的基本概念以及java实现队列

    千次阅读 2018-08-16 22:42:33
    获取队列长度 链式队列 构造函数 入队 出队 查询front 获取队列长度 循环列队 构造函数 入队 出队 查询front 获取循环队列的大小 判断队列是否为空 判断队列是否满 代码传送门,欢迎star:...
  • 用C和Java实现队列

    2021-03-27 21:12:22
    队列 什么是队列 队列是一种特殊的线性表,只允许前端删除后端插入,前端称之为队头后端为队尾,当队...获取队列长度:计算出队列中元素数量 C程序的队列操作 定义顺序队列结构 #define QUEUEMAX 15 typedef struct
  • Java 阻塞队列原理

    2021-02-15 19:28:02
    这两个附加的操作是:在队列为空时,获取元素的线程会等待队列变为非空。当队列满时,存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景,生产者是往队列里添加元素的线程,消费者是从队列里拿元素...
  • 这两个附加的操作是:在队列为空时,获取元素的线程会等待队列变为非空。当队列满时,存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景,生产者是往队列里添加元素的线程,消费者是从队列里...
  • java 优先队列

    2018-11-16 20:13:53
    就是不管入队元素,先让队列里的最大值先出队,另一种就是最小优先队列,就是不管入队元素,先让队列里的最小的元素先出队,运用二叉堆的方法可以实现它,把队列里的元素调整成大顶堆或者小顶堆,最后获取堆顶的元素...
  • 解读 Java 并发队列 BlockingQueue 转自:https://javadoop.com/post/java-concurrent-queue 最近得空,想写篇文章好好说说 java 线程池问题,我相信很多人都一知半解的,包括我自己在仔仔细细看源码之前,也有...
  • java阻塞队列

    2018-03-20 22:35:27
    这两个附加的操作是:在队列为空时,获取元素的线程会等待队列变为非空。当队列满时,存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景,生产者是往队列里添加元素的线程,消费者是从队列里拿元素...
  • Java 队列

    2018-03-13 11:30:53
    阻塞队列 含义 举例 DelayQueue 延迟队列 非阻塞队列 非阻塞算法 举例 使用场景 队列非常适合于生产者/消费者这种业务场景,像rabbitMq,activeMq都是对queue的一个封装的中间件。 阻塞队列 含义...
  • Java 阻塞队列

    2016-11-26 14:13:22
    简介Java 的阻塞队列是应用在多线程中,尤其适合生产者和消费者模式,阻塞队列支持阻塞操作,线程安全,已经实现了繁琐的简单锁和重入锁。阻塞队列框架特性 BlockingQueue不接受 null 元素。 试图 add、put或 offer...
  • 思路就是简单的bfs,首先是值为0的入队,然后每次取出队列第一个元素,更新四个方向,如果当前距离+1小于原距离,就将原距离更新即可。 注意Java中队列,offer()是添加元素,poll()取出...
  • Java阻塞队列四组API介绍 目录 第一组API,会抛出异常的:一言不合就开干 第二组:带有返回值的,不会抛出异常:为人处事会圆滑了 第三组:阻塞,一直等待:三十而立,咬定青山不放松 第四组:带有等待超时的...
  • java 阻塞队列

    2016-12-28 16:39:49
    这两个附加的操作是:在队列为空时,获取元素的线程会等待队列变为非空。当队列满时,存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景,生产者是往队列里添加元素的线程,消费者是从队列里拿元素...
  • (八)java并发队列

    2017-12-18 18:02:31
    Java并发队列在并发队列上JDK提供了两套实现: 一个是以ConcurrentLinkedQueue为代表的高性能队列; 一个是以BlockingQueue接口为代表的阻塞队列; 无论哪种都继承自Queue。 一、ConcurrentLinkedQueue定义 ...
  • java阻塞队列---BlockingQueuejava阻塞队列---BlockingQueue阻塞队列解决的问题ArrayBlockingQueueoffer()enqueue()take()dequeue()总结 java阻塞队列—BlockingQueue 阻塞队列解决的问题 为什么要用阻塞队列? 在...
  • Java实现队列和循环队列 队列接口(Interface) public interface MyQueueInterface<E> { /** * 入队 */ public void enqueue(E element); /** * 出队/删除 */ public E dequeue(); /** * 获取队首...
  • int size():获取队列长度; boolean add(E)/boolean offer(E):添加元素到队尾; E remove()/E poll():获取队首元素并从队列中删除; E element()/E peek():获取队首元素但并不从队列中删除。 要避免把null添加...
  • Java消息队列的应用

    2019-08-05 16:10:23
    消息被发送到队列中。 - “消息队列”是在消息的传输过程中保存消息的容器。消息队列管理器在将消息从它的源中继到它的目标时充当中间人。队列的主要目的是提供路由并保证消息的传递;如果发送消息时接收者不可用,...
  • java阻塞队列详解

    2020-03-25 17:51:07
    java包中有一些应用比较广泛的特殊队列: 一种是以ConcurrentLinkedQueue为代表的非阻塞队列; 另一种是以BlockingQueue接口为代表的阻塞队列。 通过这两种队列,我们保证了多线程操作数据的安全性。 队列的继承图...
  • Java阻塞队列之BlockingQueue

    千次阅读 2020-08-14 10:25:30
    当阻塞队列是空时,从队列获取元素的操作将会被阻塞 当阻塞队列是满时,往队列里添加元素的操作将会被阻塞 ArrayBlockingQueue 数组组成的有界阻塞队列 代码示例:add、remove、element(一言不合就报错...
  • Java并发队列Queue

    2018-06-29 21:24:54
    在并发队列上JDK提供了两套实现,一个是以ConcurrentLinkedQueue为代表的高性能队列,一个是以BlockingQueue接口为代表的阻塞队列,无论哪种都继承自Queue。 注:暂只做解释,后续会花时间进行完善 ...
  • java阻塞队列的使用

    千次阅读 2020-04-24 23:57:12
    当阻塞队列是空时,从队列获取元素的操作将会被阻塞 当阻塞队列是满时,往队列中添加元素的操作将会被阻塞 同样,试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞,直到其他线程从队列中移除一个或者多个...
  • 什么是顺序队列 顺序队列是先进先出的数据结构,它是一种特殊的线性表,只能在队头front进行删除操作,只能在队尾rear进行插入操作,所以把进行插入操作的一端称为队尾,进行删除操作的一端称为队头。 顺序队列的队...
  • Java实现循环队列

    2021-06-05 17:30:41
    判断队列长度5.队列入队6.队列出队7.取队头元素QueueDemoTest 什么是循环队列 顺序队列在操作时容易暴露假溢出现象,为了解决假溢出现象,我们引入了循环队列,那我们应该怎么理解循环队列呢? 循环队列是把顺序...
  • Java队列 Queue

    2021-10-18 15:50:54
    Queue 队列(Queue)是一种经常使用的集合。Queue实际上是实现了一个先进先出(FIFO:First In First Out)的有序表。...int size():获取队列长度; boolean add(E)/boolean offer(E):添加元素到队尾; E rem

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 86,920
精华内容 34,768
关键字:

java获取队列的长度

java 订阅