如何转换扩展线程类以实现可运行

我在网上找到了一些用于创建拼图的示例代码，我注意到它们具有Thread类，该类扩展Thread并执行诸如监视拼图状态甚至设置用于拼图的表面视图的属性之类的事情。

我想通过实现Runnable将此代码移到Run（）中。我读过实现Runnable比扩展Thread更好，但是我不知道如何实现。下面是从自定义表面视图调用的类。我想在此表面视图类中实现Runnable（我认为这很好）。提前致谢。

public class ThreadHelper extends Thread {

    private SurfaceHolder mHolder;
    private PuzzleSurface mPuzzleSurface;
    private ThreadHelper mThread;

    private int gameState;
    private int puzzleSurfaceWidth = 1;
    private int puzzleSurfaceHeight = 1;
    public static final int STATE_PAUSE = 1;
    public static final int STATE_RUNNING = 2;
    private boolean isRunning = false;

    public ThreadHelper(SurfaceHolder holder, PuzzleSurface puzzleSurface) {
        mHolder = holder;
        mPuzzleSurface = puzzleSurface;
    }

    /**
     * Return running thread
     * @return
     */
    public ThreadHelper getThread() {
        return mThread;
    }

    /**
     * Stop running thread
     */
    public void destroy() {
        synchronized (mPuzzleSurface) {
            if (isRunning) {
                isRunning = false;
            }

            if (mThread != null) {
                mThread.interrupt();
                mThread = null;
            }
        }
    }

    /**
     * Method pauses game state
     */
    public void pause() {
        synchronized (mPuzzleSurface) {
            if (gameState == STATE_RUNNING) {
                setState(STATE_PAUSE);
            }
        }
    }

    /**
     * Method sets game state to running
     */
    public void unpause() {
        setState(STATE_RUNNING);
    }

    /**
     * Method is used to set the game state to either paused (1)
     * or running (2) states
     * @param stateToSet
     */
    public void setState(int stateToSet) {
        synchronized (mPuzzleSurface) {
            // TODO Message Handling
        }
    }

    /**
     *  Called to retrieve per-instance state from an activity 
     *  before being killed
     * @param outState
     * @return outState instance
     */
    public Bundle saveState(Bundle outState) {
        synchronized (mPuzzleSurface) {
            if (outState != null) {

            }
        }
        return outState;
    }

    /**
     * Called to set the size of the surfaceView
     * @param width
     * @param height
     */
    public void setSurfaceSize(int width, int height) {
        // synchronized to make sure these all change atomically
        synchronized (mPuzzleSurface) {
            puzzleSurfaceWidth = width;
            puzzleSurfaceHeight = height;
        }
    }

    /* (non-Javadoc)
     * @see java.lang.Thread#getState()
     */
    @Override
    public State getState() {
        // TODO Auto-generated method stub
        return super.getState();
    }

    /**
     * Method used to set running state of thread
     * @param run
     */
    public void setRunning(boolean run) {
        isRunning = run;
    }

    /* (non-Javadoc)
     * @see java.lang.Thread#run()
     * Calls the run() method of the Runnable object the 
     * receiver holds
     */
    @SuppressLint("WrongCall")
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (isRunning) {
            Canvas c = null;
            try {
                c = mHolder.lockCanvas(null);
                synchronized (mHolder) {
                    mPuzzleSurface.onDraw(c);
                }
            } finally {
                if (c != null) {
                    mHolder.unlockCanvasAndPost(c);
                }
            }

        }
        super.run();
    }

}