Get the queue of pools sorted for scheduling
@return the queue of pools sorted for scheduling
501515
public Queue<PoolSchedulable> getScheduleQueue() {
    if (scheduleQueue == null) {
      ScheduleComparator sc = configManager.getPoolGroupComparator(getName());
      scheduleQueue = createPoolQueue(sc);
    }
    return scheduleQueue;
  }
941820
public static int getQueuedTaskCount() {
    Thread t;
    ForkJoinPool.WorkQueue q;
    if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
      q = ((ForkJoinWorkerThread) t).workQueue;
    else
      q = ForkJoinPool.commonSubmitterQueue();
    return (q == null) ? 0 : q.queueSize();
  }
3824
public List<PoolInfo> getPoolInfos() {
    Set<PoolInfo> poolInfos = new HashSet<PoolInfo>();
    for (ResourceType type : types) {
      poolInfos.addAll(getPoolInfoMetrics(type).keySet());
    }
    List<PoolInfo> result = new ArrayList<PoolInfo>();
    result.addAll(poolInfos);
    Collections.sort(result);
    return result;
  }
246206
public Queue<PoolGroupSchedulable> getScheduleQueue() {
    if (scheduleQueue == null) {
      scheduleQueue = createPoolGroupQueue(ScheduleComparator.FAIR);
    }
    return scheduleQueue;
  }
484603
public static WsByteBufferPoolManager getBufferPoolManager() {
        if (null == chfwRef.getService()) {
            return ChannelFrameworkFactory.getBufferManager();
        }
        return chfwRef.getService().getBufferManager();
    }
181841
public java.util.List<Queue> getQueues() {
        if (queues == null) {
            queues = new com.amazonaws.internal.SdkInternalList<Queue>();
        }
        return queues;
    }
598677
public Iterator<QueueUser> getUsers() {
        if (users == null) {
            return new HashSet<QueueUser>().iterator();
        }
        return Collections.unmodifiableSet(users).iterator();
    }
1197100
public PoolSchedulable getPool(PoolInfo poolInfo) {
    PoolSchedulable pool = nameToMap.get(poolInfo);
    if (pool == null) {
      pool = new PoolSchedulable(poolInfo, getType(), configManager);
      PoolSchedulable prevPool = nameToMap.putIfAbsent(poolInfo, pool);
      if (prevPool != null) {
        pool = prevPool;
      }
    }
    return pool;
  }
1339093
public synchronized List getList() {
        if (tc.isEntryEnabled())
            SibTr.entry(tc, "getList");

        // Remove a List from the pool
        List list = (List) listPool.remove();

        // If the list is null then there was none available in the pool
        // So create a new one
        if (list == null) {
            if (tc.isDebugEnabled())
                SibTr.debug(tc, "No list available from pool - creating a new one");

            // We could change the list implementation here if we wanted         
            list = new ArrayList(5);
        }

        if (tc.isEntryEnabled())
            SibTr.exit(tc, "getList");

        return list;
    }
921321
private PoolStats getPoolStats()
   {
      return new PoolStats(SECONDS.toMillis(1)) {
         @Override
         protected void update() {
            this.pendingThreads = HikariPool.this.getThreadsAwaitingConnection();
            this.idleConnections = HikariPool.this.getIdleConnections();
            this.totalConnections = HikariPool.this.getTotalConnections();
            this.activeConnections = HikariPool.this.getActiveConnections();
            this.maxConnections = config.getMaximumPoolSize();
            this.minConnections = config.getMinimumIdle();
         }
      };
   }
1266458
HashSet getQueuePointGuessSet()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getQueuePointGuessSet");

    HashSet theQueuePoints = null;

    synchronized (_queuePointsGuessSet)
    {
      theQueuePoints = (HashSet) _queuePointsGuessSet.clone();
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getQueuePointGuessSet", theQueuePoints);

    return theQueuePoints;
  }
1086691
public SchedulerStats stats() {
		int activeThreads = threadPoolExecutor.getActiveCount();
		return SchedulerStats.of(ThreadPoolStats.of(
			threadPoolExecutor.getCorePoolSize(),
			threadPoolExecutor.getMaximumPoolSize(),
			activeThreads,
			threadPoolExecutor.getPoolSize() - activeThreads,
			threadPoolExecutor.getLargestPoolSize()
		));
	}
315742
def pool(self):
        
        if self._pool is None:
            self._pool = ThreadPool(self.pool_threads)
        return self._pool
1366875
public static Map<String, String> getSchedulerNames(){
		Map<String, String> schedulerNames = new HashMap<String, String>();
		MySchedule mySchedule = MySchedule.getInstance();
		for(String settingsName: mySchedule.getSchedulerSettingsNames()){
			SchedulerSettings settings = mySchedule.getSchedulerSettings(settingsName);
			schedulerNames.put(settingsName, settings.getSchedulerFullName());
		}
		return schedulerNames;
	}
702754
public Buffer getBroadcastQueue() {

        if (m_broadcastQueue == null) {
            m_broadcastQueue = BufferUtils.synchronizedBuffer(new UnboundedFifoBuffer(QUEUE_SIZE));
        }
        return m_broadcastQueue;
    }
1040898
private Queue<PoolSchedulable> createPoolQueue(
      ScheduleComparator comparator) {
    int initCapacity =
        snapshotPools.size() == 0 ? 1 : snapshotPools.size();
    Queue<PoolSchedulable> poolQueue =
        new PriorityQueue<PoolSchedulable>(initCapacity, comparator);
    poolQueue.addAll(snapshotPools);
    return poolQueue;
  }
471445
public static Schedulers newThreadPoolScheduler(int poolSize) {
        createSingleton();
        Schedulers.increaseNoOfSchedullers();
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        CustomizableThreadFactory factory = new CustomizableThreadFactory();
        scheduler.initializeExecutor(factory, new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.out.println("asdsa");
            }
        });
        scheduler.setPoolSize(poolSize);
        instance.setCurrentScheduler(scheduler);
        return instance;
    }