這個Java應用程序如何在不擴展線程或實現可運行的情況下運行多個線程？

Question

我正在學習Java，並且能夠使用runnable對我現有的應用程序進行一些多線程處理。 我現在正在查看干擾器（在線程之間共享變量），但是我無法弄清楚作者實際上是如何生成線程的。

我看到他使用的是Executor，我用來在我的程序中提交可運行的類，但是在此示例中，沒有Submit（或可運行）。 我只是從Oracle教程中學到了知識，他們提到了僅有的兩種方法是擴展線程或實現可運行（我在這里什么都看不到，但是他確實將執行器提交給了干擾者，也許他是如何進行線程處理的？）。 我是否缺少某些東西，或者這個人以不同的方式來做？ 我的最終目標是理解此代碼（效果很好），因此我可以將其應用於現有（使用可運行的）代碼。

這是有問題的代碼：

App.java

import com.lmax.disruptor.*;
import com.lmax.disruptor.dsl.*;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class App {

    private final static int RING_SIZE = 1024 * 8;

    private static long handleCount = 0;

    private final static long ITERATIONS = 1000L * 1000L * 300L;
    private final static int NUM_EVENT_PROCESSORS = 8;

    private final static EventHandler<ValueEvent> handler =
        new EventHandler<ValueEvent>() {
        public void onEvent(final ValueEvent event,
                                final long sequence,
                                final boolean endOfBatch) throws Exception {
        handleCount++;
    }
    };

    public static void main(String[] args) {
    System.out.println("Starting disruptor app.");

    ExecutorService executor = Executors.newFixedThreadPool(NUM_EVENT_PROCESSORS);

    Disruptor<ValueEvent> disruptor =
        new Disruptor<ValueEvent>(ValueEvent.EVENT_FACTORY, executor,
            new SingleThreadedClaimStrategy(RING_SIZE),
            new SleepingWaitStrategy());
    disruptor.handleEventsWith(handler);
    RingBuffer<ValueEvent> ringBuffer = disruptor.start();

    long start = System.currentTimeMillis();

        long sequence;
        ValueEvent event;
    for (long x=0; x<ITERATIONS; x++) {
        sequence = ringBuffer.next();
        event = ringBuffer.get(sequence);
        event.setValue(x);
        ringBuffer.publish(sequence);
        }
    final long expectedSequence = ringBuffer.getCursor();

    while (handleCount < expectedSequence) { }

    long opsPerSecond = (ITERATIONS * 1000L) / (System.currentTimeMillis() - start);
    System.out.printf("op/s: %d, handled: %d", opsPerSecond, handleCount);
    }
}

更新：如果Disruptor正在處理線程的產生，那么如何向其提交現有的可運行類？ 還是我需要再次修改代碼？ 抱歉，如果中斷器要與現有代碼一起使用，或者是否需要對其進行完全更改，我有點困惑。

Answer 1

您懷疑，實際的線程處理（通過提交工作項）是在Disruptor完成的。 因此，您需要查看其源代碼 （幸運的是，它是開源的）才能找到此代碼：

public RingBuffer<T> start()
{
    EventProcessor[] gatingProcessors = eventProcessorRepository.getLastEventProcessorsInChain();
    ringBuffer.setGatingSequences(Util.getSequencesFor(gatingProcessors));

    checkOnlyStartedOnce();
    for (EventProcessorInfo<T> eventProcessorInfo : eventProcessorRepository)
    {
        executor.execute(eventProcessorInfo.getEventProcessor());
    }

    return ringBuffer;
}