ExecuteProduceConsume (Jetty :: Project 9.4.56.v20240826 API)

java.lang.Object
- org.eclipse.jetty.util.thread.strategy.ExecuteProduceConsume

All Implemented Interfaces:

java.lang.Runnable, ExecutionStrategy
```
public class ExecuteProduceConsume
extends java.lang.Object
implements ExecutionStrategy, java.lang.Runnable
```
A strategy where the thread that produces will always run the resulting task.

The strategy may then dispatch another thread to continue production.

The strategy is also known by the nickname 'eat what you kill', which comes from the hunting ethic that says a person should not kill anything he or she does not plan on eating. In this case, the phrase is used to mean that a thread should not produce a task that it does not intend to run. By making producers run the task that they have just produced avoids execution delays and avoids parallel slow down by running the task in the same core, with good chances of having a hot CPU cache. It also avoids the creation of a queue of produced tasks that the system does not yet have capacity to consume, which can save memory and exert back pressure on producers.

Nested Class Summary
- Nested classes/interfaces inherited from interface org.eclipse.jetty.util.thread.ExecutionStrategy
  ExecutionStrategy.Producer

Constructor Summary

Constructors
Constructor Description

ExecuteProduceConsume(ExecutionStrategy.Producer producer, java.util.concurrent.Executor executor)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`dispatch()`	Initiates (or resumes) the task production and consumption.
`java.lang.Boolean`	`isIdle()`
`void`	`produce()`	Initiates (or resumes) the task production and consumption.
`void`	`run()`
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - ExecuteProduceConsume
```
public ExecuteProduceConsume(ExecutionStrategy.Producer producer,
                             java.util.concurrent.Executor executor)
```
- Method Detail
  - produce
```
public void produce()
```
    Description copied from interface: ExecutionStrategy
    
    Initiates (or resumes) the task production and consumption.
    
    The produced task may be run by the same thread that called this method.
    
    Specified by:
    
    produce in interface ExecutionStrategy
    
    See Also:
    
    ExecutionStrategy.dispatch()
  - dispatch
```
public void dispatch()
```
    Description copied from interface: ExecutionStrategy
    
    Initiates (or resumes) the task production and consumption.
    
    This method guarantees that the task is never run by the thread that called this method.
    TODO review the need for this (only used by HTTP2 push)
    
    Specified by:
    
    dispatch in interface ExecutionStrategy
    
    See Also:
    
    ExecutionStrategy.produce()
  - run
```
public void run()
```
    Specified by:
    
    run in interface java.lang.Runnable
  - isIdle
```
public java.lang.Boolean isIdle()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object