Then you go to the counter 🔀, to the initial task that is now finished ⏯, pick the burgers, say thanks and take them to the table. That finishes that step / task of interaction with the counter ⏹. That in turn, creates a new task, of "eating burgers" 🔀 ⏯, but the previous one of "getting burgers" is finished ⏹.

### Parallel Burgers { #parallel-burgers }

Now let's imagine these aren't "Concurrent Burgers", but "Parallel Burgers".

Because this code is executed before the application **starts** taking requests, and right after it **finishes** handling requests, it covers the whole application **lifespan** (the word "lifespan" will be important in a second 😉).

      byteCount: Long,
    ) {
      assertLockNotHeld()

      var remainingByteCount = byteCount

      while (remainingByteCount > 0L) {
        val finished: Boolean
        val flowControlError: Boolean
        withLock {
          finished = this.finished
          flowControlError = remainingByteCount + readBuffer.size > maxByteCount
        }

            deflater.setInput(data, offset, length);
            deflater.finish();

            ByteArrayOutputStream baos = new ByteArrayOutputStream(length);
            byte[] buffer = new byte[1024];

            while (!deflater.finished()) {
                int compressedSize = deflater.deflate(buffer);
                baos.write(buffer, 0, compressedSize);
            }

                    // Process finished normally.
                    final int exitValue = p.exitValue();
                    if (exitValue != 0) {
                        logger.warn("{} failed (exit code:{}): {}", getName(), exitValue, commandList);
                    }

                    if (logger.isDebugEnabled()) {
                        logger.debug("{} is finished with exit code {}.", getName(), exitValue);

                }
            }
        }

        /**
         * Sets the finished flag to indicate whether the process has completed.
         * @param finished True if the process has finished, false otherwise.
         */
        public void setFinished(final boolean finished) {
            this.finished = finished;
        }

        /**
         * Checks if the process has been terminated due to timeout.

	// Filled during heal.
	HealedBuckets []string

	// ID of the current healing operation
	HealID string

	ItemsSkipped uint64
	BytesSkipped uint64

	RetryAttempts uint64

	Finished bool // finished healing, whether with errors or not

	// Add future tracking capabilities
	// Be sure that they are included in toHealingDisk
}

// loadHealingTracker will load the healing tracker from the supplied disk.

     * @return output stream, needs to be closed when finished
     * @throws CIFSException if an error occurs accessing the resource
     */
    OutputStream openOutputStream(boolean append) throws CIFSException;

    /**
     * Opens an output stream writing to the file (truncating, write only, sharable)
     *
     * @return output stream, needs to be closed when finished

		if hasErr > 0 && hasErr+fnf > len(disks)-opts.minDisks {
			if opts.finished != nil {
				opts.finished(errs)
			}
			return errors.Join(errs...)
		}

		// Break if all at EOF or error.
		if atEOF+hasErr == len(readers) {
			if hasErr > 0 && opts.finished != nil {
				opts.finished(errs)
			}
			break
		}

		if agree == len(readers) {
			// Everybody agreed

 * to be closed asynchronously <b>after</b> the returned {@code Future} is done: the future
 * completes before closing starts, rather than once it has finished.
 *
 * {@snippet :
 * FluentFuture<UserName> userName =
 *     ClosingFuture.submit(
 *             closer -> closer.eventuallyClose(database.newTransaction(), closingExecutor),
 *             executor)