public interface GroovySystemLoader {
    /**
     * Invoked when this Groovy system is to be discarded, so that the Groovy system can remove any static state it may have registered in other ClassLoaders.
     */
    void shutdown();

    /**
     * Invoked when another ClassLoader is discarded, so that this Groovy system can remove state for the classes loaded from the ClassLoader
     */
    void discardTypesFrom(ClassLoader classLoader);

 */
package org.codelibs.fess.job;

public abstract class JobExecutor {
    protected ShutdownListener shutdownListener;

    public abstract Object execute(String scriptType, String script);

    public void shutdown() {
        shutdownListener.onShutdown();
    }

    public void addShutdownListener(final ShutdownListener listener) {
        shutdownListener = listener;
    }

    public interface ShutdownListener {

                    textOut.style(UserInput).text(iteration).style(Normal)
                    textOut.println()
                }
            }
        }

        executor.shutdown()
        executor.awaitTermination(30, TimeUnit.SECONDS)
    }

        ) {
          response.close()
        }
      }
    repeat(10_000) {
      okhttp.newCall(Request.Builder().url(server.url("/")).build()).enqueue(callback)
    }
    okhttp.dispatcher.executorService.shutdown()
  }

	filter "istio.io/istio/pkg/kube/namespace"
	"istio.io/istio/pkg/test"
	"istio.io/istio/pkg/test/util/retry"
)

func TestNamespaceController(t *testing.T) {
	client := kube.NewFakeClient()
	t.Cleanup(client.Shutdown)
	watcher := keycertbundle.NewWatcher()
	caBundle := []byte("caBundle")
	watcher.SetAndNotify(nil, nil, caBundle)
	meshWatcher := mesh.NewTestWatcher(&meshconfig.MeshConfig{})
	stop := test.NewStop(t)

        builder.setCancellationToken(new DefaultCancellationTokenSource().token());
        builder.setParameters(connectionParameters);
        builder.setEntryPoint("Request daemon shutdown when idle");

        run(new ConsumerAction<Void>() {
            @Override
            public ConsumerOperationParameters getParameters() {
                return builder.build();
            }

				if test.signal == nil || test.signal != signalGot {
					t.Errorf("expected request context to have server shutdown signal: %p, but got: %p", test.signal, signalGot)
				}
			default:
				if signalGot != nil {
					t.Errorf("expected request context to not have server shutdown signal: %p, but got: %p", test.signal, signalGot)
				}
			}
			if test.wg == nil {
				return
			}

	return newEvent
}

func (b *backend) Run(stopCh <-chan struct{}) error {
	return b.delegateBackend.Run(stopCh)
}

func (b *backend) Shutdown() {
	b.delegateBackend.Shutdown()
}

func (b *backend) calcSize(e *auditinternal.Event) (int64, error) {
	s := &sizer{}
	if err := b.e.Encode(e, s); err != nil {
		return 0, err
	}
	return s.Size, nil
}

        GlobalUserInputReceiver userInput
    ) {
        this.userInput = userInput;
        // Use a single reader thread, and make it a daemon thread so that it does not block process shutdown
        // In most cases, we try to cleanly shut down all threads. However, in this case it is difficult to disconnect a thread blocked trying to read from the
        // process' stdin, so use a daemon thread instead.

# Set to "infinity" if you use the 'bootstrap.mlockall: true' option
# in fess.yml and 'MAX_LOCKED_MEMORY=unlimited' in ${packaging.env.file}
#LimitMEMLOCK=infinity

# Shutdown delay in seconds, before process is tried to be killed with KILL (if configured)
TimeoutStopSec=20

[Install]
WantedBy=multi-user.target