Kafka TimingWheel

package com.yit;

import java.util.Date;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.locks.StampedLock;

/**
 * Created by jenkin.z.chen on 2018/6/26.
 */
public class Timer {
    private TimingWheel timingWheel;
    private DelayQueue delayQueue;
    private final StampedLock stampedLock = new StampedLock();
    private BlockingQueue blockingQueue = new LinkedBlockingDeque<>();
    public Timer(long tickMs,int wheelSize,long startMs){
        delayQueue = new DelayQueue();
        timingWheel = new TimingWheel(tickMs,wheelSize,startMs,delayQueue);
    }

    public BlockingQueue getBlockingQueue() {
        return blockingQueue;
    }

    public void add(TimerTaskEntry timerTaskEntry){
        long stamp = stampedLock.tryOptimisticRead();
        if (!stampedLock.validate(stamp)) {
            stamp = stampedLock.readLock();
            try {
                timingWheel.add(timerTaskEntry);
                return;
            }finally {
                stampedLock.unlock(stamp);
            }
        }
        timingWheel.add(timerTaskEntry);
    }
    boolean reinsert(TimerTaskEntry timerTaskEntry){
        return timingWheel.add(timerTaskEntry);
    }
    private boolean advanceClock() throws InterruptedException {
        while(true){
            TimerTaskList timerTaskList = delayQueue.take();
            long stamp = stampedLock.writeLock();
            try{
                timingWheel.advanceClock(timerTaskList.getExpiration());
                timerTaskList.flush(this);
            }finally {
                stampedLock.unlock(stamp);
            }

        }
    }

    public static void main(String[] args) throws InterruptedException {
        Timer timer = new Timer(1000,10,System.currentTimeMillis());
        Thread thread = new Thread(()->{
            try {
                timer.advanceClock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread.start();

       // for(int i=1;i

 

package com.yit;

/**
 * Created by jenkin.z.chen on 2018/6/26.
 */
public class TimerTaskEntry {
    private final long expirations;
    public TimerTaskEntry(long expirations){
        this.expirations = expirations;
    }

    public long getExpirations() {
        return expirations;
    }
}

 

 

package com.yit;

import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Created by jenkin.z.chen on 2018/6/26.
 */
public class TimerTaskList implements Delayed {
    private CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();
    private final AtomicLong expiration = new AtomicLong(-1);
    public TimerTaskList(){

    }

    public void flush(Timer timer){
        list.stream().forEach(timerTaskEntry->{
            if(!timer.reinsert(timerTaskEntry)){
                timer.getBlockingQueue().offer(timerTaskEntry);
            }
            this.list.remove(timerTaskEntry);
        });
        expiration.set(-1);
    }
    public void add(TimerTaskEntry string){
        list.add(string);
    }
    public boolean setExpiration(long expiration){
        return this.expiration.getAndSet(expiration)!=expiration;
    }
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(Math.max(expiration.get() - System.currentTimeMillis(), 0), TimeUnit.MILLISECONDS);
    }

    public long getExpiration() {
        return expiration.get();
    }

    @Override
    public int compareTo(Delayed o) {
        TimerTaskList other = (TimerTaskList) o;

         if(getExpiration() < other.getExpiration())
             return -1;
        else if(getExpiration() > other.getExpiration())
             return 1;
        else return 0;
    }
}

 

 

package com.yit;

import java.util.concurrent.DelayQueue;

/**
 * Created by jenkin.z.chen on 2018/6/26.
 */
public class TimingWheel {
    private final long tickMs;
    private final int wheelSize;
    private final DelayQueue delayQueue;
    private final long interval;
    private final TimerTaskList[] buckets;
    private long currentTime;
    private volatile TimingWheel overflowWheel;

    public TimingWheel(long tickMs, int wheelSize,long startMs, DelayQueue delayQueue) {
        this.tickMs = tickMs;
        this.wheelSize = wheelSize;
        this.delayQueue = delayQueue;
        this.interval = tickMs*wheelSize;
        this.buckets = new TimerTaskList[wheelSize];
        for(int i=0;i= currentTime + tickMs) {
            currentTime = timeMs - (timeMs % tickMs);
            // Try to advance the clock of the overflow wheel if present
            if (overflowWheel != null) {
                overflowWheel.advanceClock(currentTime);
            }
        }
    }
}