Java 스택 및 대기열 인스턴스 분석

Stack

package com.yuzhenc.collection;

import java.util.Stack;

/**
 * @author: yuzhenc
 * @date: 2022-03-20 15:41:36
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test26 {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        stack.add("A");
        stack.add("B");
        stack.add("C");
        stack.add("D");
        System.out.println(stack);//[A, B, C, D]
        //判断栈是否为空
        System.out.println(stack.empty());//false
        //查看栈顶元素，不会移除
        System.out.println(stack.peek());//D
        System.out.println(stack);//[A, B, C, D]
        //查看栈顶元素，并且移除，即出栈（先进后出）
        System.out.println(stack.pop());//D
        System.out.println(stack);//[A, B, C]
        //入栈，和add方法执行的功能一样，就是返回值不同
        System.out.println(stack.push("E"));//返回入栈的元素 E
        System.out.println(stack);//[A, B, C, E]
    }
}

Queue

Blocking Queue

• ArrayBlockingQueue : 동시 읽기 및 쓰기 작업을 지원하지 않으며, 맨 아래 계층은 배열을 기반으로 합니다. >LinkedBlockingQueue: 동시 읽기 및 쓰기 작업을 지원하고 동시 조건에서 높은 효율성을 제공하며 하위 계층은 연결된 목록을 기반으로 합니다. ArrayBlockingQueue ： 不支持读写同时操作，底层基于数组的；

• LinkedBlockingQueue：支持读写同时操作，并发情况下，效率高，底层基于链表；

package com.yuzhenc.collection;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * @author: yuzhenc
 * @date: 2022-03-20 16:00:22
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test27 {
    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        //添加元素
        //不可以添加null，报空指针异常
        //arrayBlockingQueue.add(null);
        //arrayBlockingQueue.offer(null);
        //arrayBlockingQueue.put(null);

        //正常添加元素
        System.out.println(arrayBlockingQueue.add("Lili"));//true
        System.out.println(arrayBlockingQueue.offer("Amy"));//true
        arrayBlockingQueue.put("Nana");//无返回值

        //队列满的情况下添加元素
        //arrayBlockingQueue.add("Sam");//报非法的状态异常
        //设置最大注阻塞时间，如果时间到了队列还是满的，就不再阻塞了
        arrayBlockingQueue.offer("Daming", 3,TimeUnit.SECONDS);
        System.out.println(arrayBlockingQueue);//[Lili, Amy, Nana]
        //真正阻塞的方法，如果队列一直是满的，就一直阻塞
        //arrayBlockingQueue.put("Lingling");//运行到这永远走不下去了，阻塞了

        //获取元素
        //获取队首元素不移除
        System.out.println(arrayBlockingQueue.peek());//Lili
        //出队，获取队首元素并且移除
        System.out.println(arrayBlockingQueue.poll());//Lili
        System.out.println(arrayBlockingQueue);//[Amy, Nana]
        //获取队首元素，并且移除
        System.out.println(arrayBlockingQueue.take());//Amy
        System.out.println(arrayBlockingQueue);//[Nana]

        //清空元素
        arrayBlockingQueue.clear();
        System.out.println(arrayBlockingQueue);//[]

        System.out.println(arrayBlockingQueue.peek());
        System.out.println(arrayBlockingQueue.poll());
        //设置阻塞事件，如果队列为空，返回null，时间到了以后就不阻塞了
        System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));
        //真正的阻塞，队列为空
        //System.out.println(arrayBlockingQueue.take());//执行到这里走不下去了
    }
}

SynchronousQueue：方便高效地进行线程间数据的传送，不会产生队列中数据争抢问题；

package com.yuzhenc.collection;

import java.util.concurrent.SynchronousQueue;

/**
 * @author: yuzhenc
 * @date: 2022-03-20 21:06:47
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test28 {
    public static void main(String[] args) {
        SynchronousQueue sq = new SynchronousQueue();
        //创建一个线程，取数据：
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    try {
                        System.out.println(sq.take());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        //搞一个线程，往里面放数据：
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    sq.put("aaa");
                    sq.put("bbb");
                    sq.put("ccc");
                    sq.put("ddd");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

• PriorityBlockingQueue：带优先级的阻塞队列；

• 无界的队列，没有长度限制，但是在你不指定长度的时候，默认初始长度为11，也可以手动指定，当然随着数据不断的加入，底层（底层是数组Object[]）会自动扩容，直到内存全部消耗殆尽了，导致 OutOfMemoryError内存溢出 程序才会结束；

• 不可以放入null元素的，不允许放入不可比较的对象（导致抛ClassCastException），对象必须实现内部比较器或者外部比较器；

package com.yuzhenc.collection;

import java.util.concurrent.PriorityBlockingQueue;

/**
 * @author: yuzhenc
 * @date: 2022-03-20 21:16:56
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test29 {
    public static void main(String[] args) throws InterruptedException {
        PriorityBlockingQueue<Human> priorityBlockingQueue = new PriorityBlockingQueue<>();
        priorityBlockingQueue.put(new Human("Lili",25));
        priorityBlockingQueue.put(new Human("Nana",18));
        priorityBlockingQueue.put(new Human("Amy",38));
        priorityBlockingQueue.put(new Human("Sum",9));
        //没有按优先级排列
        System.out.println(priorityBlockingQueue);//[Human{name=&#39;Sum&#39;, age=9}, Human{name=&#39;Nana&#39;, age=18}, Human{name=&#39;Amy&#39;, age=38}, Human{name=&#39;Lili&#39;, age=25}]
        //出列的时候按优先级出列
        System.out.println(priorityBlockingQueue.take());//Human{name=&#39;Sum&#39;, age=9}
        System.out.println(priorityBlockingQueue.take());//Human{name=&#39;Nana&#39;, age=18}
        System.out.println(priorityBlockingQueue.take());//Human{name=&#39;Lili&#39;, age=25}
        System.out.println(priorityBlockingQueue.take());//Human{name=&#39;Amy&#39;, age=38}
    }
}

class Human implements Comparable <Human> {
    String name;
    int age;

    public Human() {}

    public Human(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Human{" +
                "name=&#39;" + name + &#39;\&#39;&#39; +
                ", age=" + age +
                &#39;}&#39;;
    }

    @Override
    public int compareTo(Human o) {
        return this.age-o.age;
    }

• DelayQueue：DelayQueue是一个无界的BlockingQueue

package com.yuzhenc.collection;

import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * @author: yuzhenc
 * @date: 2022-03-20 21:43:32
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test30 {
    //创建一个队列：
    DelayQueue<User> dq = new DelayQueue<>();
    //登录游戏：
    public void login(User user){
        dq.add(user);
        System.out.println("用户：[" + user.getId() +"],[" + user.getName() + "]已经登录，预计下机时间为：" + user.getEndTime() );
    }
    //时间到，退出游戏，队列中移除：
    public void logout(){
        //打印队列中剩余的人：
        System.out.println(dq);
        try {
            User user = dq.take();
            System.out.println("用户：[" + user.getId() +"],[" + user.getName() + "]上机时间到，自动退出游戏");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //获取在线人数：
    public int onlineSize(){
        return dq.size();
    }
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //创建测试类对象：
        Test30 test = new Test30();
        //添加登录的用户：
        test.login(new User(1,"张三",System.currentTimeMillis()+5000));
        test.login(new User(2,"李四",System.currentTimeMillis()+2000));
        test.login(new User(3,"王五",System.currentTimeMillis()+10000));
        //一直监控
        while(true){
            //到期的话，就自动下线：
            test.logout();
            //队列中元素都被移除了的话，那么停止监控，停止程序即可
            if(test.onlineSize() == 0){
                break;
            }
        }
    }
}
class User implements Delayed {
    private int id;//用户id
    private String name;//用户名字
    private long endTime;//结束时间
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public long getEndTime() {
        return endTime;
    }
    public void setEndTime(long endTime) {
        this.endTime = endTime;
    }
    public User(int id, String name, long endTime) {
        this.id = id;
        this.name = name;
        this.endTime = endTime;
    }
    //只包装用户名字就可以
    @Override
    public String toString() {
        return "User{" +
                "name=&#39;" + name + &#39;\&#39;&#39; +
                &#39;}&#39;;
    }
    @Override
    public long getDelay(TimeUnit unit) {
        //计算剩余时间 剩余时间小于0 <=0  证明已经到期
        return this.getEndTime() - System.currentTimeMillis();
    }
    @Override
    public int compareTo(Delayed o) {
        //队列中数据 到期时间的比较
        User other = (User)o;
        return ((Long)(this.getEndTime())).compareTo((Long)(other.getEndTime()));
    }
}

• SynchronousQueue: 서로 편리하고 효율적으로 데이터를 전송합니다. 대기열에서 데이터 경합을 일으키지 않는 스레드 문제 파악

  package com.yuzhenc.collection;
  
  import java.util.Deque;
  import java.util.LinkedList;
  
  /**
   * @author: yuzhenc
   * @date: 2022-03-20 22:03:36
   * @desc: com.yuzhenc.collection
   * @version: 1.0
   */
  public class Test31 {
      public static void main(String[] args) {
          /*
          双端队列：
          Deque<E> extends Queue
          Queue一端放 一端取的基本方法  Deque是具备的
          在此基础上 又扩展了 一些 头尾操作（添加，删除，获取）的方法
           */
          Deque<String> d = new LinkedList<>() ;
          d.offer("A");
          d.offer("B");
          d.offer("C");
          System.out.println(d);//[A, B, C]
          d.offerFirst("D");
          d.offerLast("E");
          System.out.println(d);//[D, A, B, C, E]
          System.out.println(d.poll());//D
          System.out.println(d);//[A, B, C, E]
          System.out.println(d.pollFirst());//A
          System.out.println(d.pollLast());//E
          System.out.println(d);//[B, C]
      }
  }

• PriorityBlockingQueue: 우선 순위 차단 대기열, 길이 제한은 없지만 길이를 지정하지 않는 경우 기본 초기 길이는 11 이거나 수동으로 지정할 수 있습니다. 물론 데이터가 계속 추가되면 맨 아래 레이어(맨 아래 레이어는 Object[] 배열)가 자동으로 확장됩니다. 메모리가 소모되어 OutOfMemoryError 메모리 오버플로가 발생합니다.

• No null 요소를 배치할 때 비교할 수 없는 객체는 허용되지 않습니다(결과적으로 ClassCastException 발생). 객체는 내부 비교기 또는 외부 비교기를 구현해야 합니다.

rrreee

• DelayQueue: DelayQueue는 Delayed 인터페이스를 구현하는 개체를 배치하는 데 사용되는 제한되지 않은 <code>BlockingQueue입니다.

• 생산자 스레드가 요소를 추가하기 위해 put과 같은 메서드를 호출하면 정렬을 위해 Delayed 인터페이스의 CompareTo 메서드가 트리거됩니다. 즉, 대기열에 있는 요소의 순서가 정렬됩니다. 대기열에 들어가는 순서가 아닌 만료 시간을 기준으로 합니다. 대기열의 헤드에 있는 요소가 가장 먼저 만료되고 나중에 만료될수록 더 늦게 만료됩니다.

• 소비자 스레드는 대기열의 헤드에 있는 요소를 확인하는 것이지 가져오는 것이 아닙니다. 밖으로. 그런 다음 요소의 getDelay 메소드를 호출합니다. 이 메소드에서 반환된 값이 0보다 작거나 0과 같을 경우 소비자 스레드는 대기열에서 요소를 꺼내어 처리합니다. getDelay 메소드에서 반환된 값이 0보다 크면 소비자 스레드는 wait에서 반환된 시간 값 이후에 대기열의 헤드에서 요소를 꺼냅니다. 이때 요소는 만료되어야 합니다. 이런 종류의 대기열에 null 요소를 배치하세요 ;

• DelayQueue의 기능

• Taobao 주문 비즈니스: 주문 후 30분 이내에 결제가 이루어지지 않으면 주문이 자동으로 취소됩니다.

• 배가 고프신가요? 주문 알림: 주문 완료 후 60초 사용자에게 SMS 알림을 보냅니다.

유휴 연결을 닫습니다. 서버에는 일정 시간 동안 유휴 상태가 되면

캐싱을 종료해야 하는 클라이언트 연결이 많이 있습니다. 캐시의 개체가 유휴 시간을 초과하여 캐시에서 제거해야 합니다. 🎜🎜🎜🎜작업 시간 초과 처리. 네트워크 프로토콜 슬라이딩 창이 반응적 상호 작용을 요청할 때 응답하지 않는 시간 초과 요청 등을 처리합니다.

위 내용은 Java 스택 및 대기열 인스턴스 분석의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!