Application: gvSIG desktop

	<classpathentry kind="lib" path="/libFMap_dal/lib/slf4j-api-1.5.0.jar"/>

package org.gvsig.tools.task;

public interface TaskManager {

	public Queue createQueue();

	/**

	 * Register the executor for the current thread.

	 * 

	 * @param executor

	 */

	public void registerExecutor(Executor executor) ;

	/**

	 * Get the associated executor to the current thread.

	 * 

	 * If not exist an executor for the current thread return a dumb

	 * executor. 

	 *  

	 * @return the executor for the current thread.

	 */

	public Executor getExecutor(); 	

}

package org.gvsig.tools.task.impl;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Timer;

import java.util.TimerTask;

import org.gvsig.tools.task.Executor;

import org.gvsig.tools.task.Queue;

import org.gvsig.tools.task.TaskManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultTaskManager implements TaskManager {

    final static private Logger logger = LoggerFactory.getLogger(DefaultTaskManager.class);

	class ExecutorAndThread {

		Thread thread;

		Executor executor;

		ExecutorAndThread(Thread thread, Executor executor) {

			this.thread = thread;

			this.executor = executor;

		}

	}

	class DumbExecutor implements Executor {

		public void execute(Runnable command) {

			command.run();

		}

	}

	private Map executorsByThread;

	private Executor dumbExecutor;

	private Timer timer;

	public DefaultTaskManager() {

		this.executorsByThread = new HashMap();

		this.dumbExecutor = new DumbExecutor();

		startDeadsExecutorsCollector(60000); // 1 minuto.

	}

	/**

	 * Register the executor for the current thread.

	 * 

	 * @param executor

	 */

	public void registerExecutor(Executor executor) {

		synchronized (executorsByThread) {

			ExecutorAndThread x = new ExecutorAndThread(Thread.currentThread(), executor);

			Object key = new Long(x.thread.getId());

			this.executorsByThread.put(key, x);

		}

	}

	/**

	 * Get the associated executor to the current thread.

	 * 

	 * If not exist an executor for the current thread return a dumb

	 * executor. 

	 *  

	 * @return the executor for the current thread.

	 */

	public Executor getExecutor() {

		synchronized (executorsByThread) {

			Object key = new Long(Thread.currentThread().getId());

			ExecutorAndThread x = (ExecutorAndThread) this.executorsByThread.get(key); 

			if( x != null ) {

				if( x.thread.isAlive() ) {

					return x.executor;

				}

				this.executorsByThread.remove(x);

			}

			return this.dumbExecutor;

		}

	}

	private void startDeadsExecutorsCollector(long milis) {

		if (this.timer == null){

			this.timer = new Timer();

		}

		this.timer.scheduleAtFixedRate(new TimerTask() {

			public void run() {

				try {

					collectDeadExecutors();

				} catch (Exception e) {

					DefaultTaskManager.logger.warn("Exception collecting dead executors.", e);

				}

			}

		}, milis, milis);

	}

	/*

	private void stopDeadsExecutorsCollector() {

		if (this.timer != null) {

			this.timer.cancel();

		}

	}

	*/

	private void collectDeadExecutors() {

		synchronized (executorsByThread) {

			Iterator it = this.executorsByThread.values().iterator();

			while( it.hasNext() ) {

				ExecutorAndThread x = (ExecutorAndThread) it.next();

				if( ! x.thread.isAlive() ) {

					it.remove();

				}

			}

		}

	}

	public Queue createQueue() {

		return new DefaultQueue();

	}

}

package org.gvsig.tools.task.impl;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.tools.task.Queue;

public class DefaultQueue implements Queue {

	private List list = new ArrayList();

	public DefaultQueue() {

	}

	public void clear() {

		synchronized (list) {

			list.clear();

		}

	}

	public void put(Object data) {

		synchronized (list) {

			list.add(data);

			list.notify();

		}

	}

	public Object top() throws InterruptedException {

		Object data = null;

		synchronized (list) {

			if (list.isEmpty()) {

				list.wait();

			}

			data = list.get(0);

		}

		return data;

	}

	public Object top_nowait() {

		try {

			Object data;

			synchronized (list) {

				data = list.get(0);

			}

			return data;

		} catch (Exception except) {

			return null;

		}

	}

	public Object get() throws InterruptedException {

		Object data = null;

		synchronized (list) {

			if (list.isEmpty()) {

				list.wait();

			}

			data = list.get(0);

			list.remove(0);

		}

		return data;

	}

	public Object get_nowait() {

		try {

			Object data;

			synchronized (list) {

				data = list.get(0);

				list.remove(0);

			}

			return data;

		} catch (Exception except) {

			return null;

		}

	}

	public boolean isEmpty() {

		synchronized (list) {

			return list.isEmpty();

		}

	}

	public int getSize() {

		synchronized (list) {

			return list.size();

		}

	}

}

package org.gvsig.tools.task;

public interface Queue {

	public void put(Object data);

	public Object top() throws InterruptedException;

	public Object top_nowait();

	public Object get() throws InterruptedException;

	public Object get_nowait();

	public boolean isEmpty();

	public int getSize();

	public void clear();

}

import org.gvsig.tools.task.TaskManager;

	public static final String TASK_MANAGER_NAME = "toolslocator.manager.task";

	private static final String TASK_MANAGER_DESCRIPTION = "TaskManager";

	/**

	 * Return a reference to TaskManager.

	 *

	 * @return a reference to PersistenceManager

	 * @throws LocatorException

	 *             if there is no access to the class or the class cannot be

	 *             instantiated

	 * @see Locator#get(String)

	 */

	public static TaskManager getTaskManager()

			throws LocatorException {

		return (TaskManager) getInstance().get(TASK_MANAGER_NAME);

	}

	/**

	 * Registers the Class implementing the PersistenceManager interface.

	 *

	 * @param clazz

	 *            implementing the PersistenceManager interface

	 */

	public static void registerTaskManager(Class clazz) {

		getInstance().register(TASK_MANAGER_NAME,

				TASK_MANAGER_DESCRIPTION,

				clazz);

	}

	public static void registerDefaultTaskManager(Class clazz) {

		getInstance().registerDefault(TASK_MANAGER_NAME,

				TASK_MANAGER_DESCRIPTION, clazz);

	}

import org.gvsig.tools.task.impl.DefaultTaskManager;

    	ToolsLocator.registerDefaultOperationManager(DefaultOperationManager.class);

    	ToolsLocator.registerDefaultTaskManager(DefaultTaskManager.class);