Android Open Source - Mpo_File_Parser_Example Task Manager

• Back to Image/parse  ↑

From Project

Back to project page Mpo_File_Parser_Example.

License

The source code is released under:

MIT License

Java Source Code

/*The MIT License (MIT)
*/*from   ww  w .  j  ava2 s.  c o m*/
*Copyright (c) 2014 Poming Chen
*
*Permission is hereby granted, free of charge, to any person obtaining a copy
*of this software and associated documentation files (the "Software"), to deal
*in the Software without restriction, including without limitation the rights
*to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
*copies of the Software, and to permit persons to whom the Software is
*furnished to do so, subject to the following conditions:
*
*The above copyright notice and this permission notice shall be included in all
*copies or substantial portions of the Software.
*
*THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
*IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
*AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
*LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
*OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*SOFTWARE.
*/

package tw.edu.nccu.cs.vipl.task;

import android.os.Process;


public class TaskManager extends Thread {

    private BlockingLinkedList<Runnable> mTaskList;
    private BlockingLinkedList<Runnable> mSpecTaskList;

    private Object mLocker = new Object();
    private boolean mSignal = false;
    private boolean mTerminate = false;
    private boolean mPause = false;
    private int mTreadPriority;
    private Runnable mRunningTask;

    public TaskManager(String threadName, boolean onlyOneTask, int threadPriority) {
        super(threadName);
        mTreadPriority = threadPriority;
        if (!onlyOneTask) {
            mSpecTaskList = new BlockingLinkedList<Runnable>();
        }
        mTaskList = new BlockingLinkedList<Runnable>();
        start();
    }

    public void setTaskList(BlockingLinkedList<Runnable> taskList) {
        mTaskList = taskList;
    }

    public BlockingLinkedList<Runnable> getTaskList() {
        return mTaskList;
    }

    public TaskManager(String threadName, boolean onlyOneTask) {
        this(threadName, onlyOneTask, android.os.Process.THREAD_PRIORITY_DEFAULT);
    }

    public TaskManager(String threadName, int threadPriority) {
        this(threadName, true, threadPriority);
    }

    public TaskManager(String threadName) {
        this(threadName, true, android.os.Process.THREAD_PRIORITY_DEFAULT);
    }

    @Override
    public void run() {
        Process.setThreadPriority(mTreadPriority);
        while (!mTerminate && !this.isInterrupted()) {
            mRunningTask = getTask();
            if (mRunningTask == null) {
                await();
                continue;
            }
            mRunningTask.run();

        }
    }

    private Runnable getTask() {
        if (mSpecTaskList != null) {
            Runnable runnable = mSpecTaskList.poll();
            if (runnable != null) {
                return runnable;
            }
        }
        synchronized (mLocker) {
            if (mPause) {
                return null;
            }
        }
        return mTaskList.poll();
    }

    public boolean isTerminate() {
        return mTerminate;
    }

    public void cancelRunningTask() {
        if (mRunningTask != null && mRunningTask instanceof CancelableRunnable) {
            ((CancelableRunnable) mRunningTask).cancel();
            mRunningTask = null;
        }
    }

    public void terminate() {
        clearTask();
        cancelRunningTask();
        mTerminate = true;
        signal();
    }

    public void setPause(boolean pause) {

        synchronized (mLocker) {
            mPause = pause;
        }
        if (!mPause) {
            signal();
        }
    }

    private void signal() {
        synchronized (mLocker) {
            mSignal = true;
            mLocker.notify();
        }
    }

    private boolean await() {
        synchronized (mLocker) {
            if (mSignal) {
                mSignal = false;
                return false;
            } else {
                try {
                    mLocker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return true;
            }
        }
    }

    public void submit(Runnable runnable) {
        submit(runnable, false);
    }

    public void submitFirst(Runnable runnable) {
        submitFirst(runnable, false);
    }

    public void submit(Runnable runnable, boolean isSpecTask) {
        if (isSpecTask && mSpecTaskList != null) {
            mSpecTaskList.add(runnable);
            signal();
        } else {
            mTaskList.add(runnable);
        }
        signal();
    }

    public void submitFirst(Runnable runnable, boolean isSpecTask) {
        if (isSpecTask && mSpecTaskList != null) {
            mSpecTaskList.addFirst(runnable);
        } else {
            mTaskList.addFirst(runnable);
        }
        signal();
    }

    public void clearTask() {
        if (mSpecTaskList != null) {
            mSpecTaskList.clear();
        }
        mTaskList.clear();
    }

}

Java Source Code List

• Back to Image/parse  ↑