import org.agrona.CloseHelper; //导入依赖的package包/类
@Override
public void close()
{
    CloseHelper.quietClose(reporter);

    gatewayList.forEach(CloseHelper::quietClose);
    gatewayList.clear();
    gatewaySubscriptionRepository.clear();

    serviceList.forEach(CloseHelper::quietClose);
    serviceList.clear();
    serviceSubscriptionRepository.clear();

    CloseHelper.quietClose(aeron);
    CloseHelper.quietClose(driver);
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
@Test
public void libraryDetectsEngineDisconnect()
{
    library = connectLibrary();

    awaitLibraryConnect(library);

    CloseHelper.close(engine);

    assertEventuallyTrue(
        () -> "Engine still hasn't disconnected",
        () ->
        {
            library.poll(5);
            return !library.isConnected();
        },
        AWAIT_TIMEOUT,
        () ->
        {
        }
    );
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
public synchronized void close(final int libraryId)
{
    final Agent agentToRemove = libraryIdToDelegateAgent.remove(libraryId);

    if (agentToRemove != null)
    {
        while (!dynamicAgent.tryRemove(agentToRemove))
        {
            Thread.yield();
        }

        while (!dynamicAgent.hasRemoveAgentCompleted())
        {
            Thread.yield();
        }

        if (libraryIdToDelegateAgent.isEmpty())
        {
            CloseHelper.close(runner);
            runner = null;
        }
    }
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
/**
 * Notify the archive that this control session is closed so it can promptly release resources then close the
 * local resources associated with the client.
 */
public void close()
{
    lock.lock();
    try
    {
        archiveProxy.closeSession(controlSessionId);

        if (!context.ownsAeronClient())
        {
            CloseHelper.close(controlResponsePoller.subscription());
            CloseHelper.close(archiveProxy.publication());
        }

        CloseHelper.close(context);
    }
    finally
    {
        lock.unlock();
    }
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
private void closeOnError(final Throwable ex, final String errorMessage)
{
    state = State.INACTIVE;
    CloseHelper.quietClose(replayPublication);

    if (null != cursor)
    {
        cursor.close();
    }

    if (!controlSession.isDone())
    {
        controlSession.sendResponse(
            correlationId,
            ControlResponseCode.ERROR,
            errorMessage,
            threadLocalControlResponseProxy);
    }

    if (ex != null)
    {
        LangUtil.rethrowUnchecked(ex);
    }
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
private void newRecordingSegmentFile()
{
    final File file = new File(archiveDir, segmentFileName(recordingId, segmentIndex));

    RandomAccessFile recordingFile = null;
    try
    {
        recordingFile = new RandomAccessFile(file, "rw");
        recordingFile.setLength(segmentFileLength + DataHeaderFlyweight.HEADER_LENGTH);
        recordingFileChannel = recordingFile.getChannel();
        if (forceWrites && null != archiveDirChannel)
        {
            archiveDirChannel.force(forceMetadata);
        }
    }
    catch (final IOException ex)
    {
        CloseHelper.quietClose(recordingFile);
        close();
        LangUtil.rethrowUnchecked(ex);
    }
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
/**
 * Close session and release associated resources.
 */
public void close()
{
    lock.lock();
    try
    {
        if (publication.isConnected())
        {
            closeSession();
        }

        if (!ctx.ownsAeronClient())
        {
            CloseHelper.close(subscription);
            CloseHelper.close(publication);
        }

        ctx.close();
    }
    finally
    {
        lock.unlock();
    }
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
@After
public void after()
{
    CloseHelper.close(aeronCluster);
    CloseHelper.close(container);
    CloseHelper.close(clusteredMediaDriver);

    if (null != container)
    {
        container.context().deleteDirectory();
    }

    clusteredMediaDriver.consensusModule().context().deleteDirectory();
    clusteredMediaDriver.archive().context().deleteArchiveDirectory();
    clusteredMediaDriver.mediaDriver().context().deleteAeronDirectory();
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
/**
 * Stop the server
 * @throws Exception
 */
@Override
public void close() throws Exception {
    if (subscriber != null) {
        for (int i = 0; i < subscriber.length; i++) {
            if (subscriber[i] != null) {
                subscriber[i].close();
            }
        }
    }
    if (server != null)
        server.stop();
    if (mediaDriver != null)
        CloseHelper.quietClose(mediaDriver);
    if (aeron != null)
        CloseHelper.quietClose(aeron);

}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
@Override
public void close() throws Exception
{
    writeBatchingBuffer();
    journalling.flush();

    CloseHelper.quietClose(journalling);
    DirectBufferAllocator.free(batchingBuffer);
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
@Override
public void close() throws Exception
{
    running.set(false);
    journallerThread.join();

    CloseHelper.quietClose(journalHandler);
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
@Override
public void close() throws IOException
{
    positionInFile = 0;
    journalAllocator.reset();

    CloseHelper.close(currentJournal);
    currentJournal = null;
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
private void roll() throws IOException
{
    CloseHelper.close(currentJournal);

    if (lastJournalReached() && handler != null)
    {
        handler.onJournalDepletion(this);
    }

    currentJournal = journalAllocator.getNextJournal();
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
@Override
public void close() throws Exception
{
    CloseHelper.quietClose(journalling);
    DirectBufferAllocator.free(readBuffer1.byteBuffer());
    DirectBufferAllocator.free(readBuffer2.byteBuffer());
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
@Override
public void close()
{
    gwInputProcessorList.forEach(CloseHelper::quietClose);
    gwOutputProcessorList.forEach(CloseHelper::quietClose);
    eventProcessorList.forEach(CloseHelper::quietClose);
    gatewayProcessorList.forEach(CloseHelper::quietClose);
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
@Override
public void close() throws Exception
{
    running = false;
    processorThread.join();

    CloseHelper.close(handler);
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
@Override
public void close() throws Exception
{
    running = false;
    processorThread.join();

    CloseHelper.quietClose(inputSubscription);
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
@Override
public void close()
{
    snapshotTimer.close();
    timerWheelRunning.set(false);
    timerExecutor.shutdown();

    CloseHelper.quietClose(svcInputProcessor);
    gwResponseProcessorList.forEach(CloseHelper::quietClose);
    eventProcessorList.forEach(CloseHelper::quietClose);
    CloseHelper.quietClose(journalProcessor);
    CloseHelper.quietClose(replicaProcessor);
    CloseHelper.quietClose(serviceProcessor);
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
private static <T extends Closeable> void shouldRotateNextJournalNumber(final JournalAllocator<T> allocator) throws IOException
{
    assertThat(allocator.nextJournalNumber(), is(0));

    for (int i = 0; i < JOURNAL_COUNT; i++)
    {
        final T nextJournal = allocator.getNextJournal();

        assertThat(allocator.nextJournalNumber(), is((i + 1 < JOURNAL_COUNT) ? (i + 1) : 0));

        CloseHelper.close(nextJournal);
    }

    assertThat(allocator.nextJournalNumber(), is(0));
}
 

import org.agrona.CloseHelper; //导入依赖的package包/类
public void shutdown() throws InterruptedException {
  CloseHelper.quietClose(subscription);
  CloseHelper.quietClose(publication);
  CloseHelper.quietClose(aeron);
  CloseHelper.quietClose(ctx);
  CloseHelper.quietClose(driver);
}