BlockingQueue中的remainingCapacity()方法及示例

remainingCapacity() 方法是 BlockingQueue 接口的一种，它返回可以添加到阻塞队列中的元素数量，而不会阻塞。

返回的容量有三种情况：

• 如果剩余容量为零，则无法再向阻塞队列中添加更多元素。
• 如果阻塞队列的剩余容量等于队列的大小，则无法从队列中删除元素，因为在这种情况下队列为空。
• 在任何其他情况下，容量始终等于此阻塞队列的初始容量与当前大小之间的差。

语法:

public int remainingCapacity()

返回值: 此方法返回阻塞队列的剩余容量。

Note : remainingCapacity() 方法是从Java中的 Queue 类继承而来的。

以下程序演示了 BlockingQueue 类的remainingCapacity()方法：

程序1:

// Java程序演示BlockingQueue的remainingCapacity（）
//方法
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class GFG {
 
    public static void main（String [] args）
    {
        //定义BlockingQueue的容量
        int capacityOfQueue = 7;
 
        //创建BlockingQueue对象
        BlockingQueue  BQ
            = new LinkedBlockingQueue （
                capacityOfQueue）;
 
        //向BlockingQueue添加元素
        BQ.add（“ John”）;
        BQ.add（“ Tom”）;
        BQ.add（“ Clark”）;
        BQ.add（“ Kat”）;
 
        //使用remainingCapacity（）方法查找BQ的剩余容量
        int remainingCapacity
            = BQ.remainingCapacity（）;
 
        //打印结果
        System.out.println（“队列为”+ BQ）;
 
        //打印队列的头
        System.out.println（“队列的剩余容量为”
                           + remainingCapacity）;
    }
}

队列为[John, Tom, Clark, Kat]
队列的剩余容量为3

程序2:

// Java程序演示了BlockingQueue的remainingCapacity()方法
  
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class GFG {
  
    public void findPeek()
    {
        // 定义BlockingQueue的容量
        int capacityOfQueue = 7;
  
        // 创建BlockingQueue的对象
        BlockingQueue<Employee> BQ
            = new LinkedBlockingQueue<Employee>(
                capacityOfQueue);
  
        // 添加元素到BlockingQueue
        Employee emp1
            = new Employee("Ravi", "测试员", "39000");
        Employee emp2
            = new Employee("Sanjeet", "经理", "98000");
  
        // 将Employee对象添加到BQ
        BQ.add(emp1);
        BQ.add(emp2);
  
        // 不断地将相同的元素添加到队列中，直到队列满为止
        while (BQ.size() != 7) {
  
            // 将emp2再次添加到队列中
            System.out.println(
                "添加员工成功 "
                + BQ.offer(emp2));
  
            // 使用remainingCapacity()方法查找BQ的剩余容量
            int remain = BQ.remainingCapacity();
  
            // 输出剩余容量值
            System.out.println(
                "剩余容量 :"
                + remain);
        }
    }
  
    // 创建一个包含姓名、职位和工资的Employee对象
    public class Employee {
  
        public String name;
        public String position;
        public String salary;
        Employee(String name,
                 String position,
                 String salary)
        {
            this.name = name;
            this.position = position;
            this.salary = salary;
        }
        @Override
        public String toString()
        {
            return "Employee [name=" + name
                + ", position="
                + position + ", salary="
                + salary + "]";
        }
    }
  
    // 主方法
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        gfg.findPeek();
    }
}

添加员工成功 true
剩余容量 :4
添加员工成功 true
剩余容量 :3
添加员工成功 true
剩余容量 :2
添加员工成功 true
剩余容量 :1
添加员工成功 true
剩余容量 :0

参考文献： https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/BlockingQueue.html#remainingCapacity()