Java RejectedExecutionException类代码示例

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
@Override
public ListenableFuture<?> submitListenable (Runnable task)
{
   ExecutorService executor = getThreadPoolExecutor ();
   try
   {
      ListenableFutureTask<Object> future =
         new ListenableFutureTask<Object> (task, null);
      executor.execute (future);
      return future;
   }
   catch (RejectedExecutionException ex)
   {
      throw new TaskRejectedException ("Executor [" + executor +
         "] did not accept task: " + task, ex);
   }
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
/**处理客户端请求**/
private void processRpcRequest(final ChannelHandlerContext context, final DefaultRequest request) {
    final long processStartTime = System.currentTimeMillis();
    try {
        this.pool.execute(new Runnable() {
            @Override
            public void run() {

                try {
                    RpcContext.init(request);
                    processRpcRequest(context, request, processStartTime);
                } finally {
                    RpcContext.destroy();
                }

            }
        });
    } catch (RejectedExecutionException e) {
        DefaultResponse response = new DefaultResponse();
        response.setRequestId(request.getRequestId());
        response.setException(new RpcFrameworkException("process thread pool is full, reject"));
        response.setProcessTime(System.currentTimeMillis() - processStartTime);
        context.channel().write(response);
    }

}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
/**
 * Submit a task to be executed in the future.
 * @param runnable The task to be executed.
 */
@Override
public void execute(Runnable runnable) {
  if (runnable == null) {
    throw new NullPointerException("runnable parameter is null");
  }

  if (!mWorkQueue.offer(runnable)) {
    throw new RejectedExecutionException(
        mName + " queue is full, size=" + mWorkQueue.size());
  }

  final int queueSize = mWorkQueue.size();
  final int maxSize = mMaxQueueSize.get();
  if ((queueSize > maxSize) && mMaxQueueSize.compareAndSet(maxSize, queueSize)) {
    FLog.v(TAG, "%s: max pending work in queue = %d", mName, queueSize);
  } // else, there was a race and another thread updated and logged the max queue size

  startWorkerIfNeeded();
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
public void execute(ReceivablePacket<L2GameClient> rp)
{
	try
	{
		if (rp.getClient().getState() == GameClientState.IN_GAME)
		{
			ThreadPoolManager.getInstance().executePacket(rp);
		}
		else
		{
			ThreadPoolManager.getInstance().executeIOPacket(rp);
		}
	}
	catch (RejectedExecutionException e)
	{
		// if the server is shutdown we ignore
		if (!ThreadPoolManager.getInstance().isShutdown())
		{
			_log.severe("Failed executing: "+rp.getClass().getSimpleName()+" for Client: "+rp.getClient().toString());
		}
	}
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
@Override
public void endpointNowInUse(Endpoint endpoint) {
  int count = endpointCount.incrementAndGet();
  final boolean isDebugEnabled = logger.isDebugEnabled();
  if (isDebugEnabled) {
    logger.debug("InstantiatorRecoveryTask - EndpointNowInUse. Now have {} endpoints", count);
  }
  if (count == 1) {
    synchronized (recoveryScheduledLock) {
      if (!recoveryScheduled) {
        try {
          recoveryScheduled = true;
          background.execute(new RecoveryTask());
          if (isDebugEnabled) {
            logger.debug("InstantiatorRecoveryTask - Scheduled Recovery Task");
          }
        } catch (RejectedExecutionException e) {
          // ignore, the timer has been cancelled, which means we're shutting down.
        }
      }
    }
  }
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
@SuppressLint("NewApi")
private synchronized void autoFocusAgainLater() {
	if (!stopped && outstandingTask == null) {
		AutoFocusTask newTask = new AutoFocusTask();
		try {
			// Unnecessary, our app's min sdk is higher than 11.
			// if (Build.VERSION.SDK_INT >= 11) {
			// 	newTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
			// } else {
			//
			// }
			newTask.execute();
			outstandingTask = newTask;
		} catch (RejectedExecutionException ree) {
			Log.w(TAG, "Could not request auto focus", ree);
		}
	}
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
/** Return true if a reply should be sent */
@Override
protected void basicProcess(final DistributionManager dm, final LocalRegion lclRgn) {
  Assert.assertTrue(this.serialNum != DistributionAdvisor.ILLEGAL_SERIAL);
  try {
    this.lockRoot = null;
    // may set lockRoot to the root region where destroyLock is acquired

    final boolean sendReply = true;

    // Part of fix for bug 34450 which was caused by a PR destroy region op
    // dead-locked with
    // a PR create region op. The create region op required an entry update
    // to release a
    // DLock needed by the PR destroy.. by moving the destroy to the waiting
    // pool, the entry
    // update is allowed to complete.
    dm.getWaitingThreadPool().execute(destroyOp(dm, lclRgn, sendReply));
  } catch (RejectedExecutionException e) {
    // rejected while trying to execute destroy thread
    // must be shutting down, just quit
  }
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
@Override
public RExecutorBatchFuture submit(Callable<?> ...tasks) {
    if (tasks.length == 0) {
        throw new NullPointerException("Tasks are not defined");
    }

    List<RExecutorFuture<?>> result = new ArrayList<RExecutorFuture<?>>();
    TasksBatchService executorRemoteService = createBatchService();
    RemoteExecutorServiceAsync asyncService = executorRemoteService.get(RemoteExecutorServiceAsync.class, RemoteInvocationOptions.defaults().noAck().expectResultWithin(1, TimeUnit.DAYS));
    for (Callable<?> task : tasks) {
        check(task);
        byte[] classBody = getClassBody(task);
        byte[] state = encode(task);
        RemotePromise<?> promise = (RemotePromise<?>)asyncService.executeCallable(task.getClass().getName(), classBody, state);
        RedissonExecutorFuture<?> executorFuture = new RedissonExecutorFuture(promise, promise.getRequestId());
        result.add(executorFuture);
    }
    
    List<Boolean> addResult = (List<Boolean>) executorRemoteService.executeAdd();
    if (!addResult.get(0)) {
        throw new RejectedExecutionException("Tasks have been rejected. ExecutorService is in shutdown state");
    }
    
    return new RedissonExecutorBatchFuture(result);
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
@SuppressLint("NewApi")
synchronized void autoFocusAgainLater() {
	if (!stopped && outstandingTask == null) {
		AutoFocusTask newTask = new AutoFocusTask();
		try {
			if (Build.VERSION.SDK_INT >= 11) {
				newTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
			} else {
				newTask.execute();
			}
			outstandingTask = newTask;
		} catch (RejectedExecutionException ree) {
			Log.w(TAG, "Could not request auto focus", ree);
		}
	}
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
/**
 * Initializes or doubles the capacity of array. Call either
 * by owner or with lock held -- it is OK for base, but not
 * top, to move while resizings are in progress.
 */
final ForkJoinTask<?>[] growArray() {
    ForkJoinTask<?>[] oldA = array;
    int size = oldA != null ? oldA.length << 1 : INITIAL_QUEUE_CAPACITY;
    if (size > MAXIMUM_QUEUE_CAPACITY)
        throw new RejectedExecutionException("Queue capacity exceeded");
    int oldMask, t, b;
    ForkJoinTask<?>[] a = array = new ForkJoinTask<?>[size];
    if (oldA != null && (oldMask = oldA.length - 1) >= 0 &&
        (t = top) - (b = base) > 0) {
        int mask = size - 1;
        do { // emulate poll from old array, push to new array
            ForkJoinTask<?> x;
            int oldj = ((b & oldMask) << ASHIFT) + ABASE;
            int j    = ((b &    mask) << ASHIFT) + ABASE;
            x = (ForkJoinTask<?>)U.getObjectVolatile(oldA, oldj);
            if (x != null &&
                U.compareAndSwapObject(oldA, oldj, x, null))
                U.putObjectVolatile(a, j, x);
        } while (++b != t);
    }
    return a;
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
/**
 * Initializes or doubles the capacity of array. Call either
 * by owner or with lock held -- it is OK for base, but not
 * top, to move while resizings are in progress.
 */
final ForkJoinTask<?>[] growArray() {
    ForkJoinTask<?>[] oldA = array;
    int size = oldA != null ? oldA.length << 1 : INITIAL_QUEUE_CAPACITY;
    if (size > MAXIMUM_QUEUE_CAPACITY)
        throw new RejectedExecutionException("Queue capacity exceeded");
    int oldMask, t, b;
    ForkJoinTask<?>[] a = array = new ForkJoinTask<?>[size];
    if (oldA != null && (oldMask = oldA.length - 1) >= 0 &&
        (t = top) - (b = base) > 0) {
        int mask = size - 1;
        do {
            ForkJoinTask<?> x;
            int oldj = ((b & oldMask) << ASHIFT) + ABASE;
            int j    = ((b &    mask) << ASHIFT) + ABASE;
            x = (ForkJoinTask<?>)U.getObjectVolatile(oldA, oldj);
            if (x != null &&
                U.compareAndSwapObject(oldA, oldj, x, null))
                U.putObjectVolatile(a, j, x);
        } while (++b != t);
    }
    return a;
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
public void addFailure() {
  if (blacklist.contains(location)) {
    // A second failure must have happened before we added
    // this server to the blacklist. Don't count that failure.
    return;
  }
  long failures = consecutiveFailures.incrementAndGet();
  if (failures >= THRESHOLD) {
    if (logger.isDebugEnabled()) {
      logger.debug("Blacklisting server {} for {}ms because it had {} consecutive failures",
          location, pingInterval, failures);
    }
    blacklist.add(location);
    broadcaster.serverAdded(location);
    try {
      background.schedule(new ExpireBlackListTask(location), pingInterval,
          TimeUnit.MILLISECONDS);
    } catch (RejectedExecutionException e) {
      // ignore, the timer has been cancelled, which means we're shutting down.
    }

  }
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
public Subscription schedule(Action0 action) {
    if (isUnsubscribed()) {
        return Subscriptions.unsubscribed();
    }
    Subscription ea = new ScheduledAction(action, this.tasks);
    this.tasks.add(ea);
    this.queue.offer(ea);
    if (this.wip.getAndIncrement() != 0) {
        return ea;
    }
    try {
        this.executor.execute(this);
        return ea;
    } catch (RejectedExecutionException t) {
        this.tasks.remove(ea);
        this.wip.decrementAndGet();
        RxJavaPlugins.getInstance().getErrorHandler().handleError(t);
        throw t;
    }
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
public boolean processSocket(NioChannel socket, SocketStatus status, boolean dispatch) {
    try {
        KeyAttachment attachment = (KeyAttachment)socket.getAttachment();
        if (attachment == null) {
            return false;
        }
        attachment.setCometNotify(false); //will get reset upon next reg
        SocketProcessor sc = processorCache.poll();
        if ( sc == null ) sc = new SocketProcessor(socket,status);
        else sc.reset(socket,status);
        if ( dispatch && getExecutor()!=null ) getExecutor().execute(sc);
        else sc.run();
    } catch (RejectedExecutionException rx) {
        log.warn("Socket processing request was rejected for:"+socket,rx);
        return false;
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        // This means we got an OOM or similar creating a thread, or that
        // the pool and its queue are full
        log.error(sm.getString("endpoint.process.fail"), t);
        return false;
    }
    return true;
}
 

import java.util.concurrent.RejectedExecutionException; //导入依赖的package包/类
@SuppressLint("NewApi")
private synchronized void autoFocusAgainLater() {
    if (!stopped && outstandingTask == null) {
        AutoFocusTask newTask = new AutoFocusTask();
        try {
            if (Build.VERSION.SDK_INT >= 11) {
                newTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
            } else {
                newTask.execute();
            }
            outstandingTask = newTask;
        } catch (RejectedExecutionException ree) {
            Log.w(TAG, "Could not request auto focus", ree);
        }
    }
}