When one of the work unit is aborted, call this method to abort all the other work units.
323512
public synchronized void abort(Throwable cause) {
        if (cause==null)        throw new IllegalArgumentException();
        if (aborted!=null)      return; // already aborted    
        aborted = cause;
        startLatch.abort(cause);
        endLatch.abort(cause);

        Thread c = Thread.currentThread();
        for (WorkUnit wu : workUnits) {
            Executor e = wu.getExecutor();
            if (e!=null && e!=c)
                e.interrupt();
        }
    }
403397
def abort(self, err):
        """"""
        if _debug: IOGroup._debug("abort %r", err)

        # change the state to reflect that it was killed
        self.ioState = ABORTED
        self.ioError = err

        # abort all the members
        for iocb in self.ioMembers:
            iocb.abort(err)

        # notify the client
        self.trigger()
850523
def abort(self):
        
        if self._state == _State.CLOSED:
            self._invalid_state("abort() called")
            return

        self._force_close(None)
957560
public void stop() {
        final boolean trace = TraceComponent.isAnyTracingEnabled();

        // Stop accepting work
        stopped = true;

        // Cancel futures for submitted work
        for (Future<Void> future = futures.poll(); future != null; future = futures.poll())
            if (!future.isDone() && future.cancel(true))
                if (trace && tc.isDebugEnabled())
                    Tr.debug(this, tc, "canceled", future);

        // Release running work
        for (Work work = runningWork.poll(); work != null; work = runningWork.poll()) {
            if (trace && tc.isDebugEnabled())
                Tr.debug(this, tc, "release", work);
            work.release();
        }
    }
437055
public boolean cancel(final boolean mayInterruptIfRunning, final long timeout, final TimeUnit unit)
      throws TimeoutException {
    return cancel(mayInterruptIfRunning, Optional.of(timeout), Optional.of(unit));
  }
1249537
def abort_io(self, iocb, err):
        """"""
        if _debug: IOController._debug("abort_io %r %r", iocb, err)

        # if it completed, leave it alone
        if iocb.ioState == COMPLETED:
            pass

        # if it already aborted, leave it alone
        elif iocb.ioState == ABORTED:
            pass

        else:
            # change the state
            iocb.ioState = ABORTED
            iocb.ioError = err

            # notify the client
            iocb.trigger()
308063
private void interruptWorkers() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers)
                w.interruptIfStarted();
        } finally {
            mainLock.unlock();
        }
    }
1259969
public synchronized void abort()
    {
        if (done)
            return;

        done = true;
        for (SSTableWriter writer : sstables)
            writer.abort();
        sstables.clear();
    }
574688
private void abort(List<TransactionableResourceManagerListener> listeners) throws XAException
   {
      boolean exception = false;
      for (int i = 0, length = listeners.size(); i < length; i++)
      {
         TransactionableResourceManagerListener listener = listeners.get(i);
         try
         {
            listener.onAbort();
         }
         catch (Exception e)
         {
            log.error("Could not execute the method onAbort", e);
            exception = true;
         }
      }
      if (exception)
      {
         throw new XAException(XAException.XAER_RMERR);
      }
   }
1064652
protected final void abortIfNeeded() {
        if (shouldAbort()) {
            try {
                abort();    // execute subclass specific abortion logic
            } catch (IOException e) {
                LogFactory.getLog(getClass()).debug("FYI", e);
            }
            throw new AbortedException();
        }
    }
500938
def abort(err):
    """"""
    if _debug: abort._debug("abort %r", err)

    # start with the server
    if IOServer._highlander:
        IOServer._highlander.abort(err)

    # now do everything local
    for controller in _local_controllers.values():
        controller.abort(err)
181104
def abort (aggregate):
    """"""
    while True:
        try:
            aggregate.abort()
            aggregate.finish()
            aggregate.end_log_output(interrupt=True)
            break
        except KeyboardInterrupt:
            log.warn(LOG_CHECK, _("user abort; force shutdown"))
            aggregate.end_log_output(interrupt=True)
            abort_now()
54926
public void abort()
    {
        assert descriptor.type.isTemporary;
        if (iwriter == null && dataFile == null)
            return;

        if (iwriter != null)
            iwriter.abort();

        if (dataFile!= null)
            dataFile.abort();

        Set<Component> components = SSTable.componentsFor(descriptor);
        try
        {
            if (!components.isEmpty())
                SSTable.delete(descriptor, components);
        }
        catch (FSWriteError e)
        {
            logger.error(String.format("Failed deleting temp components for %s", descriptor), e);
            throw e;
        }
    }
929919
@Override
    public void abort( long woinRefNum ){
        log.info( "Abort execution of workflow instance " + woinRefNum );
        ExecutionError error = executionErrorService.findByWoinRefNum( woinRefNum );
        if( error != null ){
            workflowInstanceService.rewindAfterError( error.getWoinRefNum() );
            if( error.getWoitRefNum() != null ){
                workItemService.rewindAfterError( error.getWoitRefNum() );
            }
            executionErrorService.delete( error.getRefNum() );
        }
        workflowInstanceService.markAbort( woinRefNum );
        workflowInstanceService.unlock( woinRefNum );
    }
540654
def abort(self):
        """"""
        resp = make_response(render_template('error.html', error=self.code, message=self.message), self.code)
        return resp
303437
def _abortJobs( self, js ):
        """"""
        self.open()
        self._client.abort(jobs = js)
        self.close()
277288
def abort(self):
        """"""
        self.set_status('aborted')
        DB.remove_from_list('{}:active'.format(self._type), self._id)
        DB.append_to_list('{}:aborted'.format(self._type), self._id)
        sbi_pb_ids = ast.literal_eval(
            DB.get_hash_value(self._key, 'processing_block_ids'))

        for pb_id in sbi_pb_ids:
            pb = ProcessingBlock(pb_id)
            pb.abort()