Disruptor 创建过程

1 Disruptor disruptor = new Disruptor<ValueEvent>(ValueEvent.EVENT_FACTORY, ringBufferSize, exec,
ProducerType.MULTI, waitStrategy);

    public Disruptor(final EventFactory<T> eventFactory,

                     final int ringBufferSize,

                     final Executor executor,

                     final ProducerType producerType,

                     final WaitStrategy waitStrategy)

    {

        this(RingBuffer.create(producerType, eventFactory, ringBufferSize, waitStrategy),

             executor);

    }

    public static <E> RingBuffer<E> create(ProducerType    producerType,

                                           EventFactory<E> factory,

                                           int             bufferSize,

                                           WaitStrategy    waitStrategy)

    {

        switch (producerType)

        {

        case SINGLE:

            return createSingleProducer(factory, bufferSize, waitStrategy);

        case MULTI:

            return createMultiProducer(factory, bufferSize, waitStrategy);

        default:

            throw new IllegalStateException(producerType.toString());

        }

    }

createMultiProducer：

    public static <E> RingBuffer<E> createMultiProducer(EventFactory<E> factory,

                                                        int             bufferSize,

                                                        WaitStrategy    waitStrategy)

    {

        MultiProducerSequencer sequencer = new MultiProducerSequencer(bufferSize, waitStrategy);//Sequencer
　　　　//public final class MultiProducerSequencer extends AbstractSequencer
　　　　//public abstract class AbstractSequencer implements Sequencer

        return new RingBuffer<E>(factory, sequencer);

    }

    RingBuffer(EventFactory<E> eventFactory,

               Sequencer       sequencer)

    {

        this.sequencer    = sequencer;

        this.bufferSize   = sequencer.getBufferSize();

        if (bufferSize < 1)

        {

            throw new IllegalArgumentException("bufferSize must not be less than 1");

        }

        if (Integer.bitCount(bufferSize) != 1)

        {

            throw new IllegalArgumentException("bufferSize must be a power of 2");

        }

        this.indexMask = bufferSize - 1;

        this.entries   = new Object[sequencer.getBufferSize()];

        fill(eventFactory);

    }

    private void fill(EventFactory<E> eventFactory)

    {

        for (int i = 0; i < entries.length; i++)

        {

            entries[i] = eventFactory.newInstance();

        }

    }

2 disruptor.handleEventsWith(eventHandlers);

    public EventHandlerGroup<T> handleEventsWith(final EventHandler<T>... handlers)

    {

        return createEventProcessors(new Sequence[0], handlers);

    }

  EventHandlerGroup<T> createEventProcessors(final Sequence[] barrierSequences,

                                               final EventHandler<T>[] eventHandlers)

    {

        checkNotStarted();

        final Sequence[] processorSequences = new Sequence[eventHandlers.length];

        final SequenceBarrier barrier = ringBuffer.newBarrier(barrierSequences);//
//ProcessingSequenceBarrier  ProcessingSequenceBarrier implements SequenceBarrier

        for (int i = 0, eventHandlersLength = eventHandlers.length; i < eventHandlersLength; i++)

        {

            final EventHandler<T> eventHandler = eventHandlers[i];

            final BatchEventProcessor<T> batchEventProcessor = new BatchEventProcessor<T>(ringBuffer, barrier, eventHandler);

            if (exceptionHandler != null)

            {

                batchEventProcessor.setExceptionHandler(exceptionHandler);

            }

            consumerRepository.add(batchEventProcessor, eventHandler, barrier);

            processorSequences[i] = batchEventProcessor.getSequence();

        }

        if (processorSequences.length > 0)

        {

            consumerRepository.unMarkEventProcessorsAsEndOfChain(barrierSequences);

        }

        return new EventHandlerGroup<T>(this, consumerRepository, processorSequences);

    }
consumerRepository 与 batchEventProcessor eventHandler SequenceBarrier 关联起来
EventHandlerGroup 与disruptor consumerRepository Sequence 关联起来

3 disruptor.start();

    public RingBuffer<T> start()

    {

        Sequence[] gatingSequences = consumerRepository.getLastSequenceInChain(true);

        ringBuffer.addGatingSequences(gatingSequences);

        checkOnlyStartedOnce();

        for (ConsumerInfo consumerInfo : consumerRepository)

        {

            consumerInfo.start(executor);//自定义的线程池执行EventProcessorInfo

        }

        return ringBuffer;

    }

class EventProcessorInfo<T> implements ConsumerInfo
    @Override
    public void start(final Executor executor)
    {
        executor.execute(eventprocessor);//batchEventProcessor 
    }

BatchEventProcessor RUN方法
  @Override
    public void run()
    {
        if (!running.compareAndSet(false, true))
        {
            throw new IllegalStateException("Thread is already running");
        }
        sequenceBarrier.clearAlert();

        notifyStart();

        T event = null;
//Concurrent sequence class used for tracking the progress of
// * the ring buffer and event processors.  Support a number
 //* of concurrent operations including CAS and order writes
        long nextSequence = sequence.get() + 1L;//使用CAS取得下一个序列号
        try
        {
            while (true)
            {
                try
                {
                    final long availableSequence = sequenceBarrier.waitFor(nextSequence);//等待策略取得可用序列号

                    if (nextSequence > availableSequence)//
                    {
                        Thread.yield();
                    }

                    while (nextSequence <= availableSequence)
                    {
                        event = dataProvider.get(nextSequence);//dataProvider 就是ringbuffer
                        eventHandler.onEvent(event, nextSequence, nextSequence == availableSequence);//触发自定义事件
                        nextSequence++;
                    }

                    sequence.set(availableSequence);
                }
                catch (final TimeoutException e)
                {
                    notifyTimeout(sequence.get());
                }
                catch (final AlertException ex)
                {
                    if (!running.get())
                    {
                        break;
                    }
                }
                catch (final Throwable ex)
                {
                    exceptionHandler.handleEventException(ex, nextSequence, event);
                    sequence.set(nextSequence);
                    nextSequence++;
                }
            }
        }
        finally
        {
            notifyShutdown();
            running.set(false);
        }
    }

4 介绍 final long availableSequence = sequenceBarrier.waitFor(nextSequence);//等待可用序列号

　　内容代码

    @Override

    public long waitFor(final long sequence)

        throws AlertException, InterruptedException, TimeoutException

    {

        checkAlert();

        long availableSequence = waitStrategy.waitFor(sequence, cursorSequence, dependentSequence, this);

        if (availableSequence < sequence)

        {

            return availableSequence;

        }

        return sequencer.getHighestPublishedSequence(sequence, availableSequence);

    }

　　6种等待策略

　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAeUAAADbCAIAAADcVR5cAAAgAElEQVR4nO2da1BUV9rvV9WpOp/fOpX308nMmUkyOW9OOScT0Qx2Wanoq0YJGlC8ARoU7WQ0yeuMOd4QaYVEAya0iEEZdQiOoCSOLWibi45pEicmGW8Dg5eORNCoiHeN7WCsdT7s27ruS3PpveXp+n2A3Wuvy7Obf6/97MX6I4zbMI6UDkEIoSFDBiKE0JBlUdyGcRvGVX6EyCNh9feBpdE2HF02BCGEkD+sFBYTLWXqbMNYP3dgadRoZUhpBJOt6KeEMxFCCGWGLbukvmvZPSctmtWjxU2rh+6qNnbtV3rUpudqjWrvaqPWq2IjiZC/igo4HVvxNWJbUbtkY+B6b5VW4hhajwbB5INHf1qMcBEHmY8o9WGgeiu6oFrYic6rEWMLc9fCrF3ph0d0OawDZf4Hrl1Epf9DBg7RPk5Kl5SzlMrjj5VemIxYXB9gtVf6Z0b0Vy+prRc+byafAQeXjP7T05tWa9beHbIMMc3Qtes9pl9a/8L829SVIw4bweX/vOPSa3GXqM+ftHvOWjSpx0KvyaiiIcui9qXKuH7MS/DREXSPDYjsO9WiFfnA+0SvnQRB/Iek95r92xY2KhoprUGSCyrpHlOYvxYm7QpOt/4cmgVK+AeuHeQUSitjnCWKANMN81jJ9Nr5B1iVYKMeq796xApfPJ83pSTXeV7riArjv2TMifoXLaLHjOg/Bl3Xqoza6R5Tsxj9XXoMrFj3hF5LukTPF2Tdc6jX8nqs9JqMuzO9pq+ov4qfrVDQf0X8N678HsiiFcnA+0avHQaBRf9IG58HzN6QccP0V2nTTJEGMReU/6uj/zrownLp4dsVnG56OawDZfIHzo+OvScgexVvrKR67fgDrDbEdJK4oNLa4v+8KT8LpMzqMxDvJTPeHVIa0W9rWL2mOyQ8mFhc2KW+gP1G6ZdAELoRqIfqD0cZoHkmtmfDGPYj5ju+Z7E5F0GmpV14jV3YpV4h7BfMFx76UUMQeilQDm9N3I+iAz08HHkYI6VDeneiYFevyUQJ95fgQnF0YZd6BVEa7qH5Y4Mg9F2gTP/AvQyXe+zVMPY2jvVadC1dKI4u7FKvIE979SMgCN0PlOkfOGA3jH3VtL18CAAAAOByQK8BAAC8Aeg1AACANwC9BgAA8Aag1wAAAN4A9BoAAMAbgF4DAAB4A9BrAAAAbwB6DQAA4A1ArwEAALwB6DUAAIA3AL0GAADwBqDXAAAA3gD0GgAAwBuAXgMAAHgD0GsAAABvAHoNAADgDUCvAQAAvAHoNQAAgDcAvQYAAPAGoNcAAADeAPQaAADAG4BeAwAAeAPQawAAAG+AquAFL3jBC15eeCEML3jBC17w8sIL8iEAAADeAPQaAADAG4BeAwAAeAPQawAAAG/QM3p95fKp+rovS5btmTejruD3oR1/jly/Gk342AAAAB4mekCvP//k0PTULa9M3L7A37Bkzp55L++cNb526gtV+8OHEj48AACAh4bu6PUNjNu2Vx3IHlO9dO6essIvSBa+0jBl1AeHIn/v+yGF/Qj5CqKJjmw/oWVHIFBR35nIPhxvrAgEdkRc0x8A6C3i1+vRRdtbz12clrIl8F+flBV+cfN6TOdU8+Wywi8Wv7r75XF/tp8YCfsRQplh8mC0wIeQLxghikWCPoT8VfJ6IkGflV6HM5H+AmXvHi7QR1KvjzdWJLw/ANBbSPW6tfXLXbvqTM78bxPf+eWUNceP/lD53lerFu//84bDyorub79sX/v2F6sW71+1eH/u+Jptmw/Y7U04E6GkYNQ4Eg0msZIaLfAh5A/bH2GVny4fDSZR3wrhTOL7gC3shO6c62Fcptd9TGRHILCjJfFXAegniPW6tfVLny/pyScfMznz33PLRq6o+eUzhW1tV5e+tmf1sr8qer1/z+mlr+1ReC3ro6L/V2+7N1V+ajYdCfqQP1jgo+WV0XQ7dRIyyjRhXtgRoNeJAvQa6C8I9FoR64kTJ5rr9SMzy2Zv3TfgpeDQlLLfv/yXwvkfK3r98c6W37/8F4U5k+ty07fa7g2Tyqjyo6RglNJBOjcdCfr0vIah6XoZdXquZz6CEUVVhekUUWG1qjA1zRc0KjwXY/VuQJx4IXIyvmCVnuThk+/xpuMjOwLai9TTzvqKgPEitaZlRyCwI9LZuIY8y/g1UN0iaojUayc1HG80+qEeV0oSXYrsCEiEuKWaGEO9PH9tBEGvVinQovSqor4TR3YEAhWNx6UjqqjvJIOmNUSMKxAgazCPMNV0d/96gf4Gq9e6WE+dOtVcr//HjDXPFWz7t18u+eKrM7PH1yx6dZei1/Xb/jF7fI3C9Be3zJ5oX6/pZEU4U9GpsF9XQGp2HA1mahNtSuhpgWOnvWE/QhLJtlNY1qhgfk3dClCFFX2nvoT0VtgbiLim7S3VjII0thjHDQXprK8girXsIHRHFx1VnqTSyaqbvRo6G6sbO5UaqIwzUZt81kyPQmlUpNeUELc0Up0karbSa1JblUHR51LzaxsRTtCtAPAwQOk1KdaWev3fJ6/+t5R3vvjqzMehlpfHbpmfu1PR6501x18eu0Uha/QHpYV7HXSISE+H/aqERYNJqtJFC3yyZEg4Uxd6c73G5HSYVW2hXtOPQCWNcudGgj66XaPzfE6GfIgaCfqId6kmbCJTOlaYsDpJVKe3TGajZQc1I5blPQSzUYc14JZqopjaSbJjVqOQrA/prK8QJSuYXtnQa6obdMcYvbYRYcltCgDYwdBrRqwt9frfZ5R9cbwtvOOfM1/aOnt8zbUrPyp6/eOdf33zxdnZ42tmjts6eURV87HjTjqkqxUhf5rSsY8K9ZkpnZ2w1Gv6XLPJrDAXIWyUPZfMhBAvf1j4yJRa9GJ8PzHabUAmE9ZoE1UNiU6Jj7dU6zUo2Qz9LUZeOxvX2NJr2zW0GPkaWsXUiTk3LukoZOv5tCjR3ea+NmzkQyQRY/XaToQhDQJ0A1WvebG21GuFYOHe7JTqVyduz399j86iV+v9GduyxlQHHU2ucRvWJTJKPmZUpVCfcesHqeSJQ73GuE1LRsvmyLxeSxsV6rW4XSu9NmbiJvcTJnhAr5W0sqbR1Py6B/WarM1EgkGvAc+g6nV9/YdPPvkYw9tvF1meH7t7Jv/1v0wZ+cHMtJo5U+pez/rotakfzkyrnTyyquztcOzuGcd9CmcilOT3J5FCGfYj5M+kBJHO85JTbyd6bZ7T4PRa3qiThSj8W8xTUHVaTUy0HSG4K5cdZ+/W+0avKcljMgzHGyu0fIhY2vhRUJlxsSYSaWWuAJs+Ms+H8M8zneVDQK+BbtAD/4/+00/ff9rwt3kztk8c/qeJw/807cXq/P/aefirI/FWqMxhaUVTV1MQk81wJqISJmb5EHqFNTljZf77hlVSkV6LG+XPZR4q4miBT2so7KfGIngEGs5Evky/L84FguxCi5Zq5Wf+OPvgzv7sWKSPTvRaa1ed//KKRsoo1yIh99LnjZ31O3TpNJ3kUqKsrDxhnjfqg2IeJ3ICbR1h0GugG/Tk/nyxu2euXD7V/XoU/eIe1rGpZOOxoa8gKs2HGCvnyEUmgrV3osJ8/lrWqKghep0fv0rPSGrz/7RJJ17igFrxFhEfp3MOtvVamn+wP0On1vxp+RBGiInFGKIpsLFgzrQ/3EhFokk8D9gR4fMhLcTSPVG6IxAgVds8wqDXQDeA/VTdAK/Xlv92D/QFoLCAqwC9dgH8E8j4njQCPQ3oNeAqQK8TQDSYxGxaIsiWwOTaBYBeA64C9DoxUIu4qf+f5La4AhIH6DXgKkCvAQAAvAHoNQAAgDcAvQYAAPAGoNcAAADeAPQaAADAG7hOr093fJVf/1Zqec6AFS/+dtX4xTtXtHZ+zRXD/zHzfR2MccK7DQAA0Nu4SK/vP2hde2DdE/kjp26emLc7Z8Xe3NfqstI3THh00fOl+8vowliTaf2V+P4DAAD0Ki7S63l1S5PfGVv4yay1jXNqDhftaiqvPbJyTeTV/D0zni4cU/PNFqIwo9fOGorXYYuuQfT/LN2vuadwT0/6Ay5Ypm26qSzwsOAWvf7yu49/sWR4wZ6ZGw7mddxq15X43PVo8b5XFoSm/yp/5A83jmrlMZEMuSSskHYVMN11zzkSvWYcwuKtmdnmKVrgM/OjEWKjJ4SBJCh7N3GBPpJ6TVmsAQ8TbtHrKRvnpK1Pz6ufeeFGG8b4TOeJhqat569/jzHed3Ln4l05L5SlFYVLtPLk/LpdWCElyrTk9d78ugfgDOAF//FoYoYght3Xm3XqCWcy/x8PJvGOcJle9zFgEt93uEWvH100LHvzxNWfFmCMu37q+sOHuXNrs+bV5Syrn5e36/W5tVlTN2akr5+tlceWjxkZUSYV1tV6ze6jHQn6kD9Iuu0INN1Onfa8FPjCjjsPep0IQK/7BW7R60fmD83eNGlD4zqM8alLJ7I3TWKYUDHhqUCKVt6pXlMJBFavaa9FTm6I/bJJC3bKfIDfL1ttkdgCm85yEOkIX7CK8dul/RaSglFKBwVD45rQy1B7cCPDG1P4fSMqrFYVpqb5gkaF57LhZb4mJUHgv1Dj/YqNGDtgC03CuC2tlS28qe25yd26JW65/Cbg9mogfTjV46zjgdyZnt7ivF6evzaCwDgnqPt6V9R32jFFI4Nm+NwbO4NTm4CbR5hqOn7R6Ie4Ra8HLE9NXZP2Zt1CjPHNuzfTyjPGlqVP2ZBd+llZ8d7VY8vSnytOfbrwJfsVUn/htLEA9xbru0jbk1PSE+S928VKqioaZZJAOuoyZ7HvEhaRvoIobgv7qaoIS4RMbaJNCb25KZrA0cbAurCsUcH8mroVoAqbBYG9gYhr2t5SzShIY4txnDFd1IspFgfqr7roiGxuSHiTBDs1dDZWa24GVMZZYrIjGB2lvwGhXlNC3NIo8c2xNokntNXwkTDOpebXNiKcoFsBz+MWvZ78xzmDisaMLs24eKMDY3ysvWlVOHisvQljHDl1cHjJuAGBUb+rWWi/QnvPGwWZAUIupY/1VL1m1JzXa2JKSFTLN8r77aryRH0xKLWZbI3txHTYmA6zAxTqtdzpxswAMxL0yfb1Ng8CbQzP+PjYQqZ0ziwWGf9GWd7DxKLXZg206bDaSdrZ0nwUkvUhEvNlzpfSUq+pbtAdc25iKblNASxxi17/9WTDE/kvjCh96Y1tCzpvX9HXh7RfPTe5MmfYu+N+tmjY0fYD9isUJA34uafwwZ0+uZM/1gv7EfIlccs2BPkQ/S1Dry390Q21IuRPUzr2USH7zeTMdFg712wyK8xFCBsVmsTzL3/YOgiE1zCt3QZkMoEzU/eASbz2rvHqDZN4LUq8ZSWYxHsQt+g1xm2ztrz56xWjR5WlTajMDuxeWf55ZX5DUcq6jBFr0p4qGP3G9jxHtZlYm/egXsvTrN3Ra62eKPmYUZVC+lEnbfPoZH7Ntm7fJF7eqFCvxe1aBkGficdnteMBvVbSyqTPb2/oNVmbiQSDXnsDF+n1nXunxlXMfmzpiCGrU0etTU95f/yYdenJxSmP549cEiq8/6DVUW229NoiHyJdR6GKpjJ/5HUWt5nptaBa7gFgOBOhJL8/iRxC2I+QP5MSRDrPS069nei1eU7DLJKYXRpofyGKZRDUaTUx0XaE4K5cdpy9W+8bvaYkj8kwHG+s0PIhYmnjRyE1rTcg0spcAZGjsTwfwj/PdJYPAb2OFxfpNcZt9x+01n675fn3Mh+ZP/Tni4c/uWx0RuUrh1o/jaMqW/kQ7qkX8/iRf5dJKzOSbU+vlWSCIXmip3/qohRK0dTVFMRkk+ytmnyQ6jW9wpqcsTJdZZVU6DcvbJQ/lw1gtMBHrasxDUI4E/ky/T7Tbxo57EKLlmrlZ/44++DO/uy4OybxZLvq/JdXNFJGuRYZ03dhfzrrd1DG7dJJLiXKysoT5nmjPijmcSIn0NYRBr2OF3fpNcnVO83dOZ153iiZBbdhTP+nH3/rTb5Lao1eoVJAW8VhR6+Z7vnDggebSgHuYR2bgTEeG/oKotJ8iDEKar2K9mKnwHRhPn8ta1TUEL3Oj08fmQWBTrzEAbXiLSI+TuccbOu1NP9gf4ZOrfnT8iGMEBOLMURTYGPBnGl/uJGKRJN4HrAjwudDWoile6J0RyBAqrZ5hEGv48W9et2fsPz/8v4AHwQIiysAhXUPoNcuwPH/lz+M8EGI70kj0NOAXrsH0OsEEA0mMft19MMdlyyD0Jv/9A84APTaPYBeJwYqvd5fVUkWBMEWV0DiAL12D6DXAAAA3gD0GgAAwBuAXgMAAHgD0GsAAABvAHoNAADgDVyn16c7vsqvfyu1PGfAihd/u2r84p0rWju/5ooZ/o2WxgUAAAAPBy7S6/sPWtceWPdE/sipmyfm7c5ZsTf3tbqs9A0THl30fOn+Mrow448Oeg0AwMOPi/R6Xt3S5HfGFn4ya23jnJrDRbuaymuPrFwTeTV/z4ynC8fUfLOFKMzodeI774juG0i6sy3ABUuVTTdWBTyOW/T6y+8+/sWS4QV7Zm44mNdxq11X4nPXo8X7XlkQmv6r/JE/3DiqlcdEMuSSsEITf5mehNwNyq4sstYz8v7TWx0xXmV6VWb/bmOjrXiGAIhxgT6Sek3ZjAEPAW7R6ykb56StT8+rn3nhRhvG+EzniYamreevf48x3ndy5+JdOS+UpRWFS7Ty5Py6XVghNa8UKF0PwFq9hDN7sgnOBF3wX3+ONx5h97Y2HQIYpTvGZXrdx4BReq/jFr1+dNGw7M0TV39agDHu+qnrDx/mzq3NmleXs6x+Xt6u1+fWZk3dmJG+frZW3qk/em9sRmGyGX9v1B8J+pA/SDrOCDTdTp32/AT4wo47D3qdCECvH2bcotePzB+avWnShsZ1GONTl05kb5rEMKFiwlOBFK28U70m8wbm+/EbG0Mb1gRi0y/OFIYvQxoYmtrQEJtE63LMW48nBaOUDgrGyFZilKH2oUaGP6RwCKLCalVhapovaFR4Lsa0nSOTeCFyMr5glX6x5MF3+gGLGLtAC42yuG2dlW2sqS2qyR2rJY6x/EbY9mogvSjV4+yu/3J3dnqb73p5/toIAuMeoO5tXVHfaccYjAya4fVu7I5NbYRtHmGqaafXtD/iFr0esDw1dU3am3ULMcY3795MK88YW5Y+ZUN26WdlxXtXjy1Lf6449enCl+xXSP1hc35XduzSw8GCKObnsIZiinxhiDoRm5CR2tAwNgKk5yxpk6hZIpCFCVuATK2TUjMdife57FvHurCsUcH8mgojVZjxoKFakQffAS3VjII0thjHGeNBvZiyzb/6qy46IqsXEt4owE4NnY3V2o7+VMZZYjQjGB2lvwGhXlNC3NIo8Y6xNkontNXwUjDOpebXNiKcoFsBr+IWvZ78xzmDisaMLs24eKMDY3ysvWlVOHisvQljHDl1cHjJuAGBUb+rWWi/QvnzRrlei9PBtD83badizCUF7jDU00KJuSL7PJDSaKI/ej7H8DM02R7aifGubAgSvZa7vZiZQEaCPtne1nxOhrwZMgu+PWRK58xmkPEwlOU9TGxqbdZAG++qnaTdHc1HIVkfIjEg5rwZLfWa6gbdMedGjpLbFECGW/T6rycbnsh/YUTpS29sW9B5+4q+PqT96rnJlTnD3h33s0XDjrYfsF+h3L/RZH6t3d3z9ldEAT7hq3030G6Eglt+3vDX3DZMb46QP03p2EeF7FeUM+Ndfgg2jNKljQqN0vmXP2xtlG4ZfDqZwBmKe8AoXXvXePWGUboWJd62EYzSvYNb9Brjtllb3vz1itGjytImVGYHdq8s/7wyv6EoZV3GiDVpTxWMfmN7nqPa5K7eVn6yurhQ2YykYNTc8UTReol9Io5Pr8k8OCuF9BNU2urQyfxaNgQbei1tVKjX4nat9Npe8OV4QK+VtDLpddsbek3WZiLBoNeuxkV6fefeqXEVsx9bOmLI6tRRa9NT3h8/Zl16cnHK4/kjl4QK7z9odVSbXK9ZiRQ/wqKM0tWZHTHXE8GoJD/5FeSULfRa6bbfT7Ub9iPkz6QEkc7zSnIvbdb5X7OchklI+Z7bX4jCv8U8BbUXfCmCu3LZcfZuvW/0mpI8JsNwvLFCy4eIpY0fhdS43YBIK3MFRK6+8nwI/zzTWT4E9NohLtJrjNvuP2it/XbL8+9lPjJ/6M8XD39y2eiMylcOtX4aR1XyfAgtpoS7OY4W+KlUKTGbC2ciX6bfx2gQOd2jlJd9NEepvxO91tarUIqmrqagu0clTMzyIXQqXzoE6xsReaP8ucxDRRwt8FGxolNJTDJdEHwHsAstWqqVn/nj7IM7+7Pj7hilk+2q819e0UgZ5VpkjM+F/ems30GZl0snuZQoKytPmOeN+qCYx4mcQFtHGPTaIe7Sa5Krd5q7czrzvFFgvK0dZ2e+iM/ktrH3/tRB9cVLW5hY2SaZqFrqtdol7mGdKMmup3Gk+RBj5Ry1IkU0BL4wfyMia1TUEL3Oj1+lZwSK/6dNYfCdQK14i4iP0zkH23otzT/Yn6FTa/60fAgjxMRiDNEU2FgwZ9ofbqQi0SSeB+yI8PmQFmLpnijdEQiQqm0eYdBrh7hXr12G5X9+U8CuHT0aamfBB3oJUNiEA3ptD4cPu0Cvuxdq2eI/IJGAXicc0GtbOP13dtBr+0SDSczqeEG2BCbXLgD0OuGAXlsg2GXJBqDXjqAeNrDZfIikWwC9Tjig1wAAAN4A9BoAAMAbgF4DAAB4A9BrAAAAbwB6DQAA4A1cp9enO77Kr38rtTxnwIoXf7tq/OKdK1o7v+aKGf6NlsYFAAAADwcu0uv7D1rXHlj3RP7IqZsn5u3OWbE397W6rPQNEx5d9Hzp/jK6MOOPDnoNAMDDj4v0el7d0uR3xhZ+Mmtt45yaw0W7msprj6xcE3k1f8+MpwvH1HyzhSjM6LWzhhLx/xe99R/V8Y9F2zZW/V8V5tce6Rism+4rXLAy2nQfV6CHcItef/ndx79YMrxgz8wNB/M6brXrSnzuerR43ysLQtN/lT/yhxtHtfKYSIZcElbIuAj2sveuJaLd+2S7LDkh3rHwG/URmzoxOysJ3OUtv35Y3xwBhGcjKHs3cYE+knpNuZoBPYhb9HrKxjlp69Pz6mdeuNGGMT7TeaKhaev5699jjPed3Ll4V84LZWlF4RKtPDm/bhdWSG+XzO2nmnC9pq0d45bsOMfC7MhB/sp5rgv+ydDEf0AMu5U2v8038+UBvuyOcJle9zH9yJfdLXr96KJh2Zsnrv60AGPc9VPXHz7MnVubNa8uZ1n9vLxdr8+tzZq6MSN9/WytvLU/Oru9vcgLsQ+R63X3+hPnufzu3savzNQ7EvQhf5A0uBFouhX27Qv4wo4AvU4UoNd9gVv0+pH5Q7M3TdrQuA5jfOrSiexNkxgmVEx4KpCilXeu14yvub+KSJiQt//E1tgi3wDxVtTCm3ryft9fINdrJrcg6wDVB+G9gpJmMXSQdk1kDcjVV5KPslZMCkZ5p/OkYJTSQUH/uQ7rZZjElG5HKfyaERWmNxNnnDaJRoXn2r9GvmCVfiH45Hu86fiIsem00JeL20Va2TWb2hGb3CBbYlDL77ttrwbS+lI9zpoMyM3g6V3F6+X5ayMIjFmBupV2RX2nHR8yMmiGtbyxGTe177Z5hKmmnV7TROIWvR6wPDV1TdqbdQsxxjfv3kwrzxhblj5lQ3bpZ2XFe1ePLUt/rjj16cKX7Fcoml8T9onMhv1ayWgwU5s2Si16w0GtWmqaScscbyiDJHrNGq4LO6BWSGpQkPdNZx3CWAdFn4l7jszZK5yp9CHspyJGuBCIO2zuQyYwkTGwLiyNEj+/ll8jJmJUK+wNRFzT9pZqRkEaW4zjjM+hXkxxFVB/1UVH5CxDwvsS2Kmhs7FaMxCgMs4SXxvB6Cj9DQj1mhLilkaJVY21LzuhrYZ1g3EuNb+2EeEE3Qp0F7fo9eQ/zhlUNGZ0acbFGx0Y42PtTavCwWPtTRjjyKmDw0vGDQiM+l3NQvsV0npNTeiYuRJv6aKiK6k4XRsJ+mTbNPP3+3E9bzSkXPp8T9VrRs1FCQdWheV6LcwdGfE02Y3aic+vMR1mxyXUa7m5jJnnZNzXiPZiZ6xzbCFTOmeuhoxloizvYeKKa7MG2udX7SRtJmk+Csn6EInfMWcFaanXVDfojjn3jZTcprgft+j1X082PJH/wojSl97YtqDz9hV9fUj71XOTK3OGvTvuZ4uGHW0/YL9C6d0xl/MVWJIbL0IumbtpOtugv/xha89vE29JcQfkz/fCfoR8SewTS2F5UpTN9dpQK0L+NKWTOZYx2QmbPr/auWaTWWEuQtio0Jc9vmtEfN/T2m1AJhM4/3IP+LJr7xqv3vBl16LEu0SCL7tz3KLXGLfN2vLmr1eMHlWWNqEyO7B7ZfnnlfkNRSnrMkasSXuqYPQb2/Mc1WZipy3Xa9onkJlV6X/8xjRTco/sTK9JuZR0wIZeW6/fcKDXWg+j5GNGVQrp6Ekj5sSXXfk6tO3LbnaZBHod3zUyZuLxudt4QK+VtDJprdsbek3WZiLBoNe2cJFe37l3alzF7MeWjhiyOnXU2vSU98ePWZeeXJzyeP7IJaHC+w9aHdUWj16bpHF1jLywySIH/i2zhIzRrrQD0rbUsSjfJXJrc3Y4VnqtHPH7k9iJvz+TEkR5xJzotXlOw+Trjb9M9heiWFwjfVpt8kEyRXBXLjvO3q33jV5TksdkGI43Vmj5ELG08aOQ+sQbEGllroDIRFieD+GfZzrLh4Be9wj3H7TWfrvl+fcyH5k/9OeLhz+5bHRG5SuHWj+No6p49Zq8/TfSEX7Rkzr2EV+0wEdlqA1NMXveSOZDZB0QPU5k1ybSkm3x+NFSr7W1KJSiqaspmBPFHeb1mk6vs+kXky8boT/b/ZEAABucSURBVMW7sFH+3LivkdqQL9PvM/2mkcMutGipVn7mj7MP7uzPjrvjy062q85/eUUjZZRrkfFZF/ans34H5ZUuneRSoqysPGGeN+qDYh4ncgJtHWHQ6x7n6p3m7pweVz6EyHr7CqLM3T3iM610lpxfAWYkTM2eNwocsLgOYMwsEKwSjEUpQC8pEXbbhl6rnRQsXqSHaRYxTmSJL4AqMgbsFJguzOev7USJWMESzzUiOun0SSMBteItIj5O5xxs67U0/2B/hk6t+dPyIYwQE4sxRFNgY8GcaX+4kYpEk3gesCPC50NaiKV7onRHIECqtnmEQa8BwOPwet1bu74AjvC0wvYsoNcA0Iax6AlkfE8agZ4G9FoH9Brop0SDScyKdUG2BCbXLgD0Wgf0Gui/UA8S+KcIsGugOwC91gG9BgAA8Aag1wAAAN4A9BoAAMAbgF4DAAB4A9BrAAAAb+A6vT7d8VV+/Vup5TkDVrz421XjF+9c0dr5NVfM8G+0NC4AAAB4OHCRXt9/0Lr2wLon8kdO3Twxb3fOir25r9VlpW+Y8Oii50v3l9GFGX900GsAAB5+XKTX8+qWJr8ztvCTWWsb59QcLtrVVF57ZOWayKv5e2Y8XTim5pstRGFGr501FK+3k1vq92JP+gMuWCZsuqkp4H3cotdffvfxL5YML9gzc8PBvI5b7boSn7seLd73yoLQ9F/lj/zhxlGtPCaSIZek1ZIbHjH7gvaiirH+A3EgcFQR2Khb7m5hoyeSEAFx4AJ9JPWasvgCHg7cotdTNs5JW5+eVz/zwo02jPGZzhMNTVvPX/8eY7zv5M7Fu3JeKEsrCpdo5cn5dbuwQnb36nCmYcDo/lknt2Ge4D/uTDbjF8PuK20SIjApjwOX6XUf049MyhOIW/T60UXDsjdPXP1pAca466euP3yYO7c2a15dzrL6eXm7Xp9bmzV1Y0b6+tlaeUt/dJON6r2g12z/I0Ef8gdJtxfxJqiWddrby58v7LjzoNeJAPT6Icctev3I/KHZmyZtaFyHMT516UT2pkkMEyomPBVI0crb0mtZroDVa9Llj9FxyVuEXZZg9wmifjVlQWzBTGc5iHSEL1jF+L3S+/0nBaOUDgpMD7gm9DIiN0tpiITWl0pVYWqaL2hUaptpEmRJEPiv1Xi/aCPGDsxCkypuS2VlC2lqe2hyt2iJWyu/CbW9GkgfSPU4u+O+3Bmd3mK7Xp6/NoLA7Nyv7itdUd9px5SLDJrhs27sTE1tQm0eYarpeESjH+IWvR6wPDV1TdqbdQsxxjfv3kwrzxhblj5lQ3bpZ2XFe1ePLUt/rjj16cKX7FcosAsh36I29ddnqbRKyt9SK9dL0t4urF4zm/RLLGCYDrP2Xb6CKG4L+6mqiC35M6X9lJtymYTITmFZo4L5tTySZkFgbyDimra3VDMK0thiHGdM//Riyhb76q+66IhsVkj4Tfrt1NDZWK3tpk9lnCUmL4LRUfobEOo1JcQtjRLfFmuTckJbDR8D41xqfm0jwgm6FfAwbtHryX+cM6hozOjSjIs3OjDGx9qbVoWDx9qbMMaRUweHl4wbEBj1u5qFjuo05nq0JDF6Ktny2OQtwfNAiXUh+8TP1JKR93tFjOmXYZpjsjWzE9NbWYgkei13WjEzYDSJpHkQaGNyxkfGFjKlc2bxx/gHyvIeJhaxNmugTW/VTtLOiuajkKwPkZj/cr6IlnpNdYPumHMTRcltCmCCW/T6rycbnsh/YUTpS29sW9B5+4q+PqT96rnJlTnD3h33s0XDjrYfiKNmbc9M2qmP8DjnX/6w6VvCG3NiMsjnQ/Rihl5b+nMbakXIn6Z0vBcw7THmzPSWD5ENk3Jpo0KTcpMgmwSBMHWjtduATCZwZt4eMCnX3jVevWFSrkWJt0wEk3JP4Ra9xrht1pY3f71i9KiytAmV2YHdK8s/r8xvKEpZlzFiTdpTBaPf2J7XjcqVvASnYiZLLExXX/SJXpNZclYK6a30aZtBJ/NrWYhs6LW0UaFe2w4yf5ORFIzGa/XiAb1W0sqkz2xv6DVZm4kEg167HRfp9Z17p8ZVzH5s6Yghq1NHrU1PeX/8mHXpycUpj+ePXBIqvP+gtVv1i1XMZI2E1QoTfnoryBrL9VpQP/cAMJyJUJLfTxkHh/0I+TMpQaTzvJLMTJt1/tcspyH0zxU36mQhimUQ1Gm1iXuyKYK7ctlx9m69b/Sakjwmw3C8sULLh4iljR+F1DTdgEgrcwVEjrryfAj/PNNZPgT02jku0muM2+4/aK39dsvz72U+Mn/ozxcPf3LZ6IzKVw61fuq8KmVBhf4rZ08ued6FowU+yfNA8i324Vs4k31oZq3XSiV0lobNI6sm4pSiqaspGHdzMmFilg+hV1hLQ8QrqdDvXNgof65VJE2DEM5Evky/z/SbRg670KKlWvmZP84+uLM/O+6OSTnZrjr/5RWNlFGuRcZ0XNifzvodlHG4dJJLibKy8oR53qgPinmcyAm0dYRBr53jLr0muXqnuXs1VJHJVRPpoZag0ZM42VvU4jYir83Vb6bXmM7/+sOC/1dUCnAP6+T99BVEpfkQY+UctV5FFCK+MJ8CkjUqasgsyFZBoBMvcUCteIuIj9M5B9t6Lc0/2J+hU2v+tHwII8TEYgzRFNhYMGfaH26kItEkngfsiPD5kBZi6Z4o3REIkKptHmHQa+e4V6/dTO/8x43l/5f3B/ggQFhcASisGwC9jode0WvH/1/+MMIHIb4njUBPA3rtBkCv46FH9DoaTGL263D9f8n3PJZBoFfCAAkD9NoNgF7HQ0/Nr6n1y/1VlWRBEGxxBSQO0Gs3AHoNAADgDUCvAQAAvAHoNQAAgDcAvQYAAPAGoNcAAADewHV6fbrjq/z6t1LLcwasePG3q8Yv3rmitfPrhPcKAAAg4bhIr+8/aF17YN0T+SOnbp6Ytztnxd7c1+qy0jdMeHTR86X7yxLePQAAgMTiIr2eV7c0+Z2xhZ/MWts4p+Zw0a6m8tojK9dEXs3fM+PpwjE132zpqYa84N/YK92W/e+JewLinp70B1ywpNp0A1iAwy16/eV3H/9iyfCCPTM3HMzruNWu+xWcux4t3vfKgtD0X+WP/OHGUZu1MS6C9JZGrOeLq6AdAEx3yIuvcoFe90BABO4z0QKfuYGOABs9IcweXXsRvYIL9JHUa8oODRDiFr2esnFO2vr0vPqZF260YYzPdJ5oaNp6/vr3GON9J3cu3pXzQllaUbjEcc2OTcT7GNNtpmnJ6735dQ/AxVnw34mON0hhg8O66oQzmf9lB0N3R7hMr/sYTxq6u0WvH100LHvzxNWfFmCMu37q+sOHuXNrs+bV5Syrn5e36/W5tVlTN2akr5/tuGZP6zWtsK7Wa3bP60jQh/xB0hknjmth3/dAEMnuXIV+Aug16HWcPDJ/aPamSRsa12GMT106kb1pEsOEiglPBVIc1yzSCNYLxl9FbeVMpVME9/jim3HapdBEZfTWmaSNaJtpqc2CaYtGu0xXWfUXNKq2KI0AkY7wBasYb1zaGyEpGKV0UDA0rgnT4HD+OxomkQxT03xBo8JzLa61JAj8F2q8X7ERY7dqoaEXt/20st02tZU2ubO2xNmW37DbXg2kZ6Z6nHUnkLvI09uR18vz10YQGJcDdQ/uivpOOwZmZNAMT3pjF29qw27zCGtNO1ahnsMtej1geWrqmrQ36xZijG/evZlWnjG2LH3KhuzSz8qK964eW5b+XHHq04UvOa7Zjl7rf6X6n6gqCrRAUFXR8kT7y9B5DHOjFtP5NW0CwL0la1F9l5SeIO+zbmKIwxgaSAx3GC8YKlkRzlQqDPvFcYgGM4WRtA6ORLLtFJY1Kphfy6+1WRDYD1tc0/aWakZBGluM44xBol5MsSNQf9VFR2RJQ8IbGtipobOxWnMeoDLOEkMcwego/Q0I9ZoS4pZGiceNtaE78QVgeD4Y51LzaxsRTtCtgIFb9HryH+cMKhozujTj4o0OjPGx9qZV4eCx9iaMceTUweEl4wYERv2uZqHjmu3oNZN/EEtkJOiT7cssuE838Wm0JUn8dM/KdpJoUfpYT9VrRs15vWbNd2SGk7w3LuEfr38xGNbGkmSIE4NgYzrMDlAYSbkrjZlZpaNrHWFuMuhvTae2ODKlc2aHyHgtyvIeJna6NmugDYLVTtIulOajkKwPkRglcx6SlnpNdYPumHPDScltSl/iFr3+68mGJ/JfGFH60hvbFnTevqKvD2m/em5yZc6wd8f9bNGwo+0HHNdsLx8ifAuzciN4+cOSx2hGu92YX8vmnuYtyh/rhf0I+ZK4ZRs9ZeiuqxUxKE3p2EeF7DeTM4Ng7VyzyawwFyFsVGjobvtaU0EgfIFp7TYgkwmc8bkHDN21d41Xbxi6a1Hi7SX7t6G7W/Qa47ZZW9789YrRo8rSJlRmB3avLP+8Mr+hKGVdxog1aU8VjH5je1481faoXovvbXtRr6n+96Bey9Os3dFrrZ4o+ZhRHSAdZ9qS0cn8mm3dvqG7vFGhXtu+1vxNhn4VnD/o9oBeK2ll0pO3N/SarM1EgkGvE8ede6fGVcx+bOmIIatTR61NT3l//Jh16cnFKY/nj1wSKrz/oDWeantKr80WJzjLTvSAXjvMwFCV+6vU+aO4SyYGwXy13APAcCZCSX5/EjmEsB8hfyY1TPqisJ7xdvXaPKdhFknMLg20vxDFMgjqtJr45DhCcFcuO87erfeNXlOSx2QYjjdWaPkQsbTxo5AazBsQaWWugMh9WJ4P4Z9nOsuHgF4z3H/QWvvtluffy3xk/tCfLx7+5LLRGZWvHGr9NP46e0yv2QdNOFrgkzyIYx4GUolUZWkBLUny2bf0WZx5i/y7TFqZkWybhu5hP5WCED39UxelUIqmrqYgrgLZWzX5INVreoU1eSmZrppH0qxR/lyTa20dhHAm8mX6fabfNHLYhRYt1crP/HH2wZ392XF3DN3JdtX5L69opIxyLTIG7cL+dNbvoEzWpZNcSpSVlSfM80Z9UMzjRE6grSMMem3C1TvNPVBPz+k1ZtZ+ydd4cS0Sy8j8VUId0TWOed5o0jfTFul3Sa2hlrsgfRWHHb1muucPCx5sKgW4h3VsuKgFlNJ8CBscapEiPwXmI2mvUVFDZtfaKgh04iUOqBVvEfFxOudgW6+l+Qf7M3RqzZ+WD2GEmFiMIZoCGwvmTPvDjVQkmsTzgB0RPh/SQizdE6U7AgFStc0jDHoNeBnL/y/vD/BBgLC4ApcobM8Ceg3Ei+P/L38Y4YMQ35NGoKcBvQb6NdFgErNfRz/ccckyCL35T/+AA0Cvgf4OlV7vr6okC4JgiysgcYBeAwAAAAkD9BoAAMAbJFivf3rQtv8freV7o0UfnQYAoD9Qvje6/x+tPz1IvPx5jgTr9e6/n9lz5NL5a3dv3esCAKA/cP7a3T1HLu3++5mEy5/nSLBeF4dOX/3x3tW79678GAMAoD9w9e69qz/eKw6dTrj8eY4E63XRR6dv3uvqvBPT+frsqTd3lI4um/V/lqcOXjnx93WrD7d/RxbovBPDGP/HzPd1MMZMAQAA3MzNe11FH4FeO8YFeh3runw7dvl27MLNO6s++eDxpaOmbp6Ytztnxd7c1+qy0jdMeHTRsKK9m5UyCopeY+JFvgsAgMu5GQO9jofE6/WNWFfH7VjH7dirW4t+u2pc4Sez1jbOqTlctKupvPbIyjWRV/P3zPi/K1LWfxFSinVweq0ft0ntDISeLTnUrWLNhc8iNCPkqMI+wD096Q+4INou/RxacgP0Oi4Sr9fX7nZdvBWr/8eh/7XkPwv2zNxwMK/jVruuxeeuR4v3vbIgNP2JpS8cO3/u4q3YxVtUPuTKj/9SDpJsnYEQyt1KHWxe/ixCz5b8zfiBPUtQibRY8/JnEZoRomu2qNCiLabDR0sGITRoVbOkUXmvzHvyUa7xvx7d6zNg+gnpG3r4c9hnXLsLeh0PLtDrH7su3Iylr5+Xtj49r37mhRttGOMznScamraev/49xnjfyZ2Ld+W8UJa2aOe6CzdjF25S8+uLt2LKQQpF7FY2G0c+ykUoeflRUWEJf85B6NmSg+J3m5c/i1BOyH5tFnDdO7gyWZFUowNHSwYhlP2R/WpD2XT5gyuTEcr9M9EoESK2sBO6c66HMf2E9A09/Tl0QLcu+rUfQa/jIfF6ffXHrvM3Yv9z0fDszRNXf1qAMe76qesPH+bOrc2aV5ezrH5e3q7X59ZmTd2Y8WL5nPM3YudvGHqt/CpkSw5CKHeL+mtz4FmEckIm5cU1PFvypfjdeCo0JZSFUNLKZrL+rJUlScYQYuc/zEUoOXDEWZ1ZH8qaMC/suPPxnuthTD8hfUOPfw7t062LfhX0Oi4Sr9edd7rar8cemT80e9OkDY3rMManLp3I3jSJYULFhP9d8GL79Vj7dUOvlV/FHClJQiirTv85OXBEfeuDHIQGlzTSJdUXcZwtVkdkEnJKAoMRyglxJZuV441vJ2tFcz8ge0VUkvR2iKikOTCYbC6UhZIDR0JZ+hDY/jQHBiO+Cb0M0QGlreb266EsZPSZRFRYreoD5S1ydHSjwnNNomoSBDbgoiP2CGUJmya7RARWbYi8amwM6Yso6p6TGqRhJLokvVj2PodUEJiPEHFNQ1nkJeNHNLikkQya1pCti85HmGj66zug1/GQeL2+fLvr7LXYUwXjUtekvVm3EGN88+7NtPKMsWXpUzZkl35WVrx39diy9OeKUwcsTz97LWafP72M0OCSiPLDyyH++NlrsbN1uQglLzusvNW8bLDxFlcMZdYRNSCjTqJk87LBCCE08O3ms9diZ6+FMolikbeTTSqJvJ2MUO6f9Oa0npNVaT/HIm/nWvf5WiiTaI5vkca6sKxR/lyTqJoFgTpLVK0d6nKJ+MfOHi5ZVie4gmcPlwwkiindUH89XDIQkWOnLqLwA+aoBhvXrnnZYMllsvs5pD4tf3qb6iRRM1VMOCLjKiuDos/lLrpFhPXTL98GvY6HxOt1x+2u1quxce/PG1Q0ZnRpxsUbHRjjY+1Nq8LBY+1NGOPIqYPDS8YNCIyaVlXQejXmgL+XDERo6lslA1Fy/t+N45tfRmhwyYGrsdarzfmD0dTtzClqYaJYaCpCA99qJipvzh+M0MshYYXaz7HWq7EDbyUjlLvZRiVqb7drFb4cUk9Xavs7OwqD7blaE2RP1Bap0an9Uf9y6HrYwptfRnq15o1y55pE1TwIzfmDiXepJmxCh5QeHd0ueWmYuLFjZ94VfZDirIEP48C3msmOWY1C8jkkPktsh6ma2QrZEdHdoDvGXHQbESZq6wC9jovE6/XFW13fXYlt/eaLx5aOHlH60hvbFnTevqKvD2m/em5yZc6wd8c9unB4Q9Px767EHLFpOkIIoekh9uDgkv1XYt99o82D6NeUbYJiykGN5qWDjWqNkvTx767E9hclI5S7yUYlyq8Di5q/uxKaopf8pmQgSl76DVEPMzT1pb5F9CRG1SMMC0pe+o1+kC1MV2XWKHuuSVStgrC/KJmM5MCiZq7zzUuNZALZf6NpwZCFx7fl6jVsmk5dNWbsRK+4aGjHHdUgCaMeOm5c0lGYfg4RewW5axqagqggsyNiRk1ETHjRLSJM1HbxFuh1PCRery/c7DrdGTvdGZuyMW/A8jGjytImVGYHdq8s/7wyv6EoZV3GiDVp/7FsTM4HhUoxZ3xd8gxKzvuaOrhxOkKDSz5T30WTt4nPNS3WnDcYoekhtiR9/HRn7LOiZIRyN9qoxKjn65JnlFM6Y6c7Q5MRmrwttnE6WTI0GSGkl9mWq/9M9MQ4VxKc5rzBRCVcYboqs0bZc02iahkE/XqJLpy9yy1qWnh8Wy7SmqDDy479s6JkOhSCYrZrMAmj2k8kG7iDzyFZG91J7po+U9QsHREzaiJiti46E2Gitgs3Qa/jIfF6ff5m18nLsZOXY0fPXxtZNueXeSOHrE4dtTY95f3xY9alJxen/HLpqN/VvvvPS3eUYs74uuQZlLzka+pg5XSEBpV8cjl28nJoMkLPFDYLzzUtFpqMEJoe4ko2LxlkHD95OfZJYTJCuZU2Kjl5OXayNheh5MnTk7XatMqn505GaHItVUwfFNEE2RO1fuMsntpc/US+MF2VWaPcuSZRtQxC85JB6JnC5k8KqSDYRta04DgbN+JCMGOXdYYsZrcGszBajt3+55C5yurV4QqwH1d2REbfLD9dNiJMNH0e9DouXKDXN7pOdMQUmi/eeW//riHF0x+ZP/Rni/7z8fwxKeWvbz/8rV7AMYdKnkHJiw9RByunITSo5JOO2IkO5SOFJtUS5aeF+GKV0xAi6qmchhBCSFCyefEg47hWf26ljUpOdMROdIQmIYQQeqaw2ThYq6wHIEZRm2v0+ZAyhyKa0Pqs1EZUFZpEhYLpKlOYqcqsUf5ci6iaB6E2Fw3KnTSION0JbNO1ucrP/HHy18ppVB+YsasCql8g2SfETg22rh15abgW7XwOD5VM0i9Hba5+CntN1Rq066h80qjPPDEoOmLWF52PMNH0+Rug1/GQeL0+d73rn5diPH/7vkN43BmHSn6Dkhcdog6un4bQoJK92q97VxCLk4jjTLH104xSE2uaFw1CaFqIK0kd1yrPXW+jErLAxBpmCFRPqD4PKtlbk6s3wfT5nzXq2q/frGj+56XYPy+FJhJ5U+2guDBblbxRUUPSqNoIgtJJonKnaJ1R5EZ8nP5UrJ9GlRR8QkTXlyxmuwZxGNdPo7ukXPRpIf4TZe9zSBYzquWvqVq/Fiu2hkEl64nrSH0sRRfdIsJE0+eug17HQ+L1uv1aV/PFWL+keeEghLJDie6G24IAYXEFFdkIDSoJ907l7ddAr+Mh8Xp99lrXPy7E+iMHS36DUMafE90NtwXhYMlvUPKCg4nuWL/n/WyEBpXs7p3Kz4Jex0Xi9fr7a13HL8T6Aw3Lk3+zvFn7NZSBEBpU0pDoXrktCOuyEcoOJbyfwLrsXvx8fg96HRcJ1uv3GqInL8WaLtw79kOsP1CeTeT3skMJ74+rgtAQSEYIoaSShkT3EDimXKbeuRZNF+6dvBR7ryGacPnzHAnW671HzoS+7Yhevvf9tS4AAPoD0cv3Qt927Dn8XcLlz3MkWK//df9sw7dnikOJ92wGAKBvKA6dbvj2zL/un024/HmOBOs1AAAAYBPQawAAAG8Aeg0AAOANQK8BAAC8Aeg1AACANwC9BgAA8Aag1wAAAN4A9BoAAMAbgF4DAAB4A9BrAAAAbwB6DQAA4A1ArwEAALwB6DUAAIA3AL0GAADwBqDXAAAA3gD0GgAAwBuAXgMAAHgD0GsAAABvAHoNAADgDUCvAQAAvAHoNQAAgDcAvQYAAPAGoNcAAADeAPQaAADAG/x/V0S99ZTEC7YAAAAASUVORK5CYII=" alt="" />

//MultiProducerSequencer   Sequencer   
 @Override

    public long getHighestPublishedSequence(long lowerBound, long availableSequence)

    {

        for (long sequence = lowerBound; sequence <= availableSequence; sequence++)

        {

            if (!isAvailable(sequence))

            {

                return sequence - 1;//实际上实现了循环等待

            }

        }

        return availableSequence;

    }

    @Override

    public boolean isAvailable(long sequence)

    {

        int index = calculateIndex(sequence);

        int flag = calculateAvailabilityFlag(sequence);

        long bufferAddress = (index * SCALE) + BASE;

        return UNSAFE.getIntVolatile(availableBuffer, bufferAddress) == flag;

    }

5 disruptor.publishEvent(eventTranslator, msg);

    public <A> void publishEvent(final EventTranslatorOneArg<T, A> eventTranslator, A arg)

    {

        ringBuffer.publishEvent(eventTranslator, arg);

    }

RingBuffer.class
public <A> void publishEvent(EventTranslatorOneArg<E, A> translator, A arg0)

    {

        final long sequence = sequencer.next();

        translateAndPublish(translator, sequence, arg0);

    }

  final long sequence = sequencer.next(); 
//MultiProducerSequencer 
    public long next()
    {
        return next(1);
    }
  public long next(int n)
    {
        if (n < 1)
        {
            throw new IllegalArgumentException("n must be > 0");
        }

        long current;
        long next;

        do
        {
            current = cursor.get();
            next = current + n;

            long wrapPoint = next - bufferSize;
            long cachedGatingSequence = gatingSequenceCache.get();

            if (wrapPoint > cachedGatingSequence || cachedGatingSequence > current)
            {
                long gatingSequence = Util.getMinimumSequence(gatingSequences, current);

                if (wrapPoint > gatingSequence)
                {
                    LockSupport.parkNanos(1); // TODO, should we spin based on the wait strategy?
                    continue;
                }

                gatingSequenceCache.set(gatingSequence);
            }
            else if (cursor.compareAndSet(current, next))
            {
                break;
            }
        }
        while (true);

        return next;
    }

    private void translateAndPublish(EventTranslator<E> translator, long sequence)

    {

        try

        {

            translator.translateTo(get(sequence), sequence);// 取位置 调用自定义类设置值 
　　　　　　　　//上面是自定义设置值类    
　　　　// EventTranslatorOneArg<ValueEvent, String> eventTranslator = new EventTranslatorOneArg<ValueEvent, String>() {
      //   @Override
      //  public void translateTo(ValueEvent event, long sequence, String msg) {
      //      event.setValue(msg);
      //  }
    };

        }

        finally

        {

            sequencer.publish(sequence);

        }

    }
//   MultiProducerSequencer
 public void publish(final long sequence)
    {
        setAvailable(sequence);//设置可用
        waitStrategy.signalAllWhenBlocking();
    }
//SingleProducerSequencer
    public void publish(long sequence)
    {
        cursor.set(sequence);//cursor就是 Sequence
        waitStrategy.signalAllWhenBlocking();
    }

Disruptor 创建过程的更多相关文章

ASP.NET Web API 控制器创建过程(二)
ASP.NET Web API 控制器创建过程(二) 前言本来这篇随笔应该是在上周就该写出来发布的,由于身体跟不上节奏感冒发烧有心无力,这种天气感冒发烧生不如死,也真正的体会到了什么叫病来如山倒,病 ...
ASP.NET Web API 控制器创建过程(一)
ASP.NET Web API 控制器创建过程(一) 前言在前面对管道.路由有了基础的了解过后,本篇将带大家一起学习一下在ASP.NET Web API中控制器的创建过程,这过程分为几个部分下面的内 ...
Spring MVC 学习 -- 创建过程
Spring MVC 学习 -- 创建过程 Spring MVC我们使用的时候会在web.xml中配置 <servlet> <servlet-name>SpringMVC< ...
Web APi之过滤器创建过程原理解析【一】（十）
前言 Web API的简单流程就是从请求到执行到Action并最终作出响应,但是在这个过程有一把[筛子],那就是过滤器Filter,在从请求到Action这整个流程中使用Filter来进行相应的处理从 ...
.NET/ASP.NET MVC Controller 控制器（IController控制器的创建过程）
阅读目录: 1.开篇介绍 2.ASP.NETMVC IControllerFactory 控制器工厂接口 3.ASP.NETMVC DefaultControllerFactory 默认控制器工厂 4 ...
图解JAVA对象的创建过程
前面几篇博文分别介绍了JAVA的Class文件格式.JVM的类加载机制和JVM的内存模型,这里就索性把java对象的创建过程一并说完,这样java对象的整个创建过程就基本上说明白了(当然你要有基础才能 ...
JVM中对象的创建过程
JVM中对象的创建过程如以下流程图中所示: 对其主要步骤进行详细阐述: 为新生对象分配内存: 内存的分配方式: 指针碰撞:假设Java堆中内存是绝对规整的,所有用过的内存放在一边,空闲的内存在另一边, ...
Java中对象创建过程
本文介绍的对象创建过程仅限于普通Java对象,不包括数组和Class对象. 1.类加载检查虚拟机遇到一条new指令时,首先去检查该指令的参数能否在常量池中定位到一个类的符号引用,并且检查这个符号引用 ...
XMPie部署与创建过程 - 快速指南
XMPie部署与创建过程 1PhotoShop.Indesign.VS2013关系.作用.使用 .1.1目的与过程 1. Photoshop负责导出cpkg文件. 1.1 动态性如果你想要生成动态的 ...

随机推荐

C# html的Table导出到Excel中
C#中导出Excel分为两大类.一类是Winform的,一类是Web.今天说的这一种是Web中的一种,把页面上的Table部分导出到Excel中. Table导出Excel,简单点说,分为以下几步: ...
细说JavaScript对象(3)：hasOwnProperty
判断一个属性是定义在对象本身而不是继承自原型链,我们需要使用从 Object.prototype 继承而来的 hasOwnProperty 方法. hasOwnProperty 方法是 JavaScr ...
SQL获取当月天数的几种方法
原文:SQL获取当月天数的几种方法日期直接减去int类型的数字等于 DATEADD(DAY,- 数字,日期) 下面三种方法: 1,日期加一个月减去当前天数,相当于这个月最后一天的日期.然后获取天数 ...
C++之纯虚函数
1. 纯虚函数形式 class Parent { public: ; }; 代码中的func1就是纯虚函数,没有函数体,没有函数的具体实现,有virtual,在函数名后面带有“ = 0”形式: 2.对 ...
python测试与调试提示
测试与调试提示 2.1 在交互模式输入一个python语句就会执行一个.在调试程序时,这种模式尤其有用. 2.2 在一个文件调用python解释器后,解释器会在文件中的最后一个语句执行之后推出.然而, ...
python学习心得（三）
一,面向对象编程 1,类和实例, class Student(object):#括号里面的是继承的类 def __init__(self, name, score):初始化对象时,参数个数 self. ...
全栈技术经理——团队管理：每周问问你的团队这这些问题 V1.0
全栈技术经理--团队管理:每周问问你的团队这这些问题 V1.0 1.本周取得了哪些进展? 通过回答这个问题可以让员工庆祝甚至夸耀一些自己的成果,包括那些跟最高优先级不相干而被忽视的小事情.借此你也 ...
.Net程序测试使用阿里云OCS开放缓存服务
首先需要有一个阿里的OCS实例和ECS云服务器请确认这两个是在同一个可用区的,这个很重要! 这两个可以在阿里云官网申请得到拿到OCS之后进入OCS控制台,点击下面的客户端下载选择.Net客 ...
fabricjs line
let line1 = new fabric.Line([lineleft, lineheight, lineleft, 0], {//终止位置,线长,起始位置,top,这里是从项目中截下来的我用了变 ...
时间操作（JavaScript版）—最简单比較两个时间格式数据的大小
呵呵呵,在软件研发过程中假设遇到要比較两个时间的大小.你会怎么做.嗯嗯嗯,非常直观的做法就是把"-"去掉,再比較大小,真的有必要吗?看以下最简单的时间比較方式: <!DOCT ...

Disruptor 创建过程

Disruptor 创建过程的更多相关文章

随机推荐

热门专题