手写Handler

CurHandler.java

public class CurHandler extends Thread {
    private List<Runnable> mRunnableList;
    private Map<Long, Runnable> mWaitRunnableList;
    private boolean mIsquit;

    public CurHandler() {
        mRunnableList = Collections.synchronizedList(new ArrayList<Runnable>());
        mWaitRunnableList = Collections.synchronizedMap(new TreeMap<Long, Runnable>());
        start();
    }

    @Override
    public void run() {
        System.out.println("mRunnableList "+mRunnableList.size() +" mWaitRunnableList "+mWaitRunnableList.size());
        while (!mIsquit) {
            List<Runnable> runnableList = new ArrayList<>( mRunnableList);
            mRunnableList.clear();
            for (Runnable runnable : runnableList) {
                runnable.run();
            }
            synchronized (this) {
                long timeMillis = System.currentTimeMillis();
                Iterator<Map.Entry<Long, Runnable>> iterator = mWaitRunnableList.entrySet().iterator();
                while (iterator.hasNext()) {
                    Map.Entry<Long, Runnable> entry = iterator.next();
                    if (entry.getKey() <= timeMillis) {
                        iterator.remove();
                        mRunnableList.add(entry.getValue());
                    } else {
                        timeMillis = entry.getKey() - timeMillis;
                        break;
                    }
                }
                if (!mRunnableList.isEmpty()) {
                    continue;
                } else if (!mWaitRunnableList.isEmpty()) {
                    cWait(timeMillis);
                }
                if (mRunnableList.isEmpty() && mWaitRunnableList.isEmpty()) {
                    cWait(0);
                }
            }
        }
    }

    private void cWait(long l) {
        try {
            if (l == 0) {
                wait();
            } else {
                wait(l);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void quit() {
        synchronized (this) {
            mIsquit = true;
            cNotify();
        }
    }

    public void cNotify(){
        notifyAll();
    }
    public void postDelayed(Runnable runnable, long delayTime) {
        synchronized (this) {
            mWaitRunnableList.put(System.currentTimeMillis() + delayTime, runnable);
            System.out.println("mWaitRunnableList add");
            cNotify();
        }
    }

    public void post(Runnable runnable) {
        synchronized (this) {
            mRunnableList.add(runnable);
            System.out.println("mRunnableList add");
            cNotify();
        }
    }

    public void removeCallbacks(Runnable updateLoadRunnable) {
        synchronized (this) {
            Iterator<Map.Entry<Long, Runnable>> iterator = mWaitRunnableList.entrySet().iterator();
            while (iterator.hasNext()) {
                if (iterator.next().getValue().equals(updateLoadRunnable)) {
                    iterator.remove();
                }
            }
        }
    }
}

Test.java

public class CurTest {
    @Test
    public void test() {
        final CurHandler curHandler = new CurHandler();
        System.out.println("test thread "+Thread.currentThread().getName());
        Runnable delayRunnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("delay thread  " + Thread.currentThread().getName() + " run");
                curHandler.postDelayed(this, 5000);
            }
        };

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("thread " + Thread.currentThread().getName() + " run");
            }
        };

        curHandler.post(runnable);
        curHandler.post(runnable);
        curHandler.postDelayed(delayRunnable, 2000);
        curHandler.postDelayed(delayRunnable, 9000);
        curHandler.removeCallbacks(delayRunnable);

        try {
            Thread.sleep(2000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}