Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.cache.tile.impl.pool;

import java.util.Collections;

import java.util.LinkedList;

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.cache.tile.exception.TileGettingException;

import org.gvsig.raster.cache.tile.pool.AtomicTask;

import org.gvsig.raster.cache.tile.pool.ThreadPool;

import org.gvsig.raster.cache.tile.pool.TilePipe;

import org.gvsig.raster.cache.tile.provider.TileListener;

/**

 * Pool of threads. This class contains a list of tasks and a limited number

 * of threads to execute them. When a thread is free will execute the next task 

 * in the list. 

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class ThreadPoolImpl implements ThreadPool {

        private int                        NTHREADS_POOL   = 5;

        private ThreadTask[]               threadList      = null;

        private LinkedList<AtomicTask>     tasks           = new LinkedList<AtomicTask>();

        private boolean                    priorityActive  = false;

        private TilePipe                   tilePipe        = null;

        /**

         * Constructor. Only for testing purposes. After this constructor the method init

         * has to be called

         */

        public ThreadPoolImpl() {

                this.priorityActive = true;

                threadList = new ThreadTask[NTHREADS_POOL];

        }

        /**

         * Constructor

         * @param priorityActive true if the pool runs using priorities and false if doesn't

         * @param nThreads Number of threads of this pool

         */

        public ThreadPoolImpl(boolean priorityActive, int nThreads) {

                this.priorityActive = true;

                NTHREADS_POOL = nThreads;

                init();

        }

        /**

         * Constructor

         * @param priorityActive true if the pool runs using priorities and false if doesn't

         */

        public ThreadPoolImpl(boolean priorityActive) {

                this.priorityActive = priorityActive;

                init();

        }

        public void init() {

                if(threadList == null)

                        threadList = new ThreadTask[NTHREADS_POOL];

                for (int i = 0; i < NTHREADS_POOL; i++) {

                        threadList[i] = new ThreadTask(this);

                        threadList[i].start();

                }

        }

        /**

         * Cancel the pool of threads

         * @param listener

         */

        public void cancelPool(TileListener listener) {

                if(threadList != null) {

                        for (int i = 0; i < NTHREADS_POOL; i++) {

                                if(threadList[i] != null) {

                                        Runnable r = threadList[i].stopThread();

                                        try {

                                                listener.tileReady((Tile)r);

                                        } catch (TileGettingException e) {

                                        }

                                }

                        }

                }

                for (int i = 0; i < tasks.size(); i++) {

                        try {

                                listener.tileReady((Tile)tasks.get(i));

                        } catch (TileGettingException e) {

                        }

                }

                synchronized (tasks) {

                        tasks.notifyAll();

                }

                destroyPool();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.cache.tile.pool.ThreadPool#getTilePipe()

         */

        public TilePipe getTilePipe() {

                if(tilePipe == null)

                        tilePipe = new TilePipeImpl();

                return tilePipe;

        }

        /**

         * Stops all threads in the list and sets the list to null

         */

        public void destroyPool() {

                for (int i = 0; i < NTHREADS_POOL; i++) {

                        threadList[i].stopThread();

                        threadList[i] = null;

                }

                threadList = null;

        }

        /**

         * Returns true if the pool is valid

         * @return

         */

        public boolean isPoolValid() {

                return !(threadList == null);

        }

        /**

         * Adds a new task to the list

         * @param task

         */

        public void addTask(AtomicTask task) {

                synchronized (tasks) {

                        tasks.addLast(task);

                        tasks.notify();

                }

        }

        /**

         * Gets the next task in the list

         * @return

         */

        public Runnable getNext() {

                Runnable returnVal = null;

                synchronized (tasks) {

                        while (tasks.isEmpty()) {

                                try {

                                        tasks.wait();

                                } catch (InterruptedException ex) {

                                        System.err.println("Interrupted");

                                }

                        }

                        if(priorityActive)

                                sort(tasks);

                        returnVal = (Runnable) tasks.removeFirst();

                }

                return returnVal;

        }

        /**

         * Sorts the array of tasks. Each atomic task have to implement AtomicTask interface

         * which is Runnable and Comparable. The last one allow to sort the array 

         * by priorities.

         * @param tasks

         */

        private void sort(LinkedList<AtomicTask> tasks) {

                Collections.sort(tasks);

        }

}