Running process in background.

answered 2010-01-31 04:44:03 +0800

mjablonski
1284 ● 3 ● 5
http://www.jease.org/

Hi,

please read: http://docs.zkoss.org/wiki/Long_Operations

Cheers, Maik

answered 2010-02-01 11:25:03 +0800

yuzexu_zk
240 ● 2

updated 2010-02-01 12:16:07 +0800

hello din:

maybe you need the same to you

i also want to export the report in background and the the report may be have 10000 and above data

the operate will cost much long time

this is part of code

public class TaskQueues
{
private static Scheduler scheduler = new Scheduler();
private static List<Task> taskQueue = new LinkedList<Task>();
private static TaskQueues _taskQueues = new TaskQueues();
private static List<TaskMonitor> _taskMonitors = new LinkedList<TaskMonitor>();
private TaskQueues()
{

}

public static TaskQueues getInstance()
{
return _taskQueues;
}

public void registerTaskMonitor(TaskMonitor taskMonitor)
{
synchronized(_taskMonitors)
{
_taskMonitors.add(taskMonitor);
//将当前其拥有的任务推送过去
synchronized(taskQueue)
{
for(final Task task : taskQueue)
{
if(taskMonitor.getOwner().equals(task.getOwner()))
taskMonitor.addTask(task);
}
}
}
}

public boolean unregisterTaskMonitor(TaskMonitor taskMonitor)
{
synchronized(_taskMonitors)
{
return _taskMonitors.remove(taskMonitor);
}
}
private Task getTask(String identity)
{
for(final Task _task : taskQueue)
{
if(_task.getIdentity().equals(identity))
return _task;
}
return null;
}

/**
* 添加任务到任务队列
* @param task
*/
public void addTask(Task task)
{
if(StringUtils.isEmpty(task.getIdentity()))
throw new IllegalStateException("任务标识不能为空!");
synchronized(taskQueue)
{
//检查任务标识
final Task _task = getTask(task.getIdentity());
if(_task != null)
throw new IllegalStateException("已经存在标识为:" + _task.getIdentity() + "的任务!");
//启动任务
Timer timer = new Timer();
timer.schedule(new TaskScheduler(task), 1000);
taskQueue.add(task);
synchronized(_taskMonitors)
{
for(final TaskMonitor taskMonitor : _taskMonitors)
{
if(taskMonitor.getOwner().equals(task.getOwner()))
taskMonitor.addTask(task);
}
}
}
}
/**
* 从任务队列中移除任务
* @param identity
* @return
*/
public boolean removeTask(String identity)
{
synchronized(taskQueue)
{
final Task _task = getTask(identity);
if(_task != null)
{
//先停止任务
if(_task.isAlive())
_task.stop();
synchronized(_taskMonitors)
{
for(final TaskMonitor taskMonitor : _taskMonitors)
{
if(taskMonitor.getOwner().equals(_task.getOwner()))
taskMonitor.removeTask(_task);
}
}
return taskQueue.remove(_task);
}
}
return false;
}
/**
* 取消任务
* @param identity
* @return
*/
public boolean cancelTask(String identity)
{
synchronized(taskQueue)
{
final Task _task = getTask(identity);
if(_task != null)
{
//先停止任务
if(_task.isAlive())
{
_task.stop();
return true;
}
}
}
return false;
}

public interface Task
{

public String getIdentity();

/**
* 设置任务拥有者
* @param owner
*/
public void setOwner(String owner);

public String getOwner();

/**
* 任务开始时间
* @return
*/
public Date getStartTime();

/**
* 任务完成时间
* @return
*/
public Date getFinishTime();

/**
* 返回操作名称.
* @return
*/
public String getOperateName();
/**
* 返回任务名称.
* @return
*/
public String getTaskName();
/**
* 返回任务是否执行成功
* @return
*/
public boolean isSuccess();

/**
* 执行操作.
* @throws Exception
*/
public void execOperate() throws Exception;
/**
* 任务是否活着.
* @return
*/
public boolean isAlive();

public void start();

public void stop();

}

public class TaskMonitor extends Thread
{

private String _identity;

private String _owner;

private boolean _ceased;

private final Desktop _desktop;

private TaskAction _taskAction;

//新增的任务
private List<Task> _newTaskList = new LinkedList<Task>();
//移出的任务
private List<Task> _removeTaskList = new LinkedList<Task>();

private List<Task> _finishTaskList = new LinkedList<Task>();

public TaskMonitor(String identity , String owner , Desktop desktop , TaskAction taskAction)
{
_identity = identity;
_owner = owner;
_desktop = desktop;
_taskAction = taskAction;
}

public String getIdentity()
{
return _identity;
}

public String getOwner()
{
return _owner;
}

public TaskQueues getTaskQueues()
{
return TaskQueues.getInstance();
}

public void notifyTaskFinish(Task task)
{
synchronized(_finishTaskList)
{
_finishTaskList.add(task);
}
}
public void addTask(Task task)
{
synchronized(_newTaskList)
{
_newTaskList.add(task);
}
}

public void removeTask(Task task)
{
synchronized(_removeTaskList)
{
_removeTaskList.add(task);
}
}

public void run()
{
if(_ceased)
return;
if (!_desktop.isServerPushEnabled())
_desktop.enableServerPush(true);
getTaskQueues().registerTaskMonitor(this);
try {
while (!_ceased)
{
try
{
if (_newTaskList.isEmpty()
&& _removeTaskList.isEmpty()
&& _finishTaskList.isEmpty())
{
Threads.sleep(1000);// Update each 1 seconds
}
else
{
Executions.activate(_desktop);
try
{
process();
} finally
{
Executions.deactivate(_desktop);
}
}
} catch (DesktopUnavailableException ex)
{
throw ex;
} catch (Throwable ex)
{
throw UiException.Aide.wrap(ex);
}
}
} finally
{
getTaskQueues().unregisterTaskMonitor(this);
if (_desktop.isServerPushEnabled())
_desktop.enableServerPush(false);
}
}

private void renderTask()
{
while (!_newTaskList.isEmpty())
{
Task task ;
synchronized (_newTaskList)
{
task = _newTaskList.remove(0);
}
_taskAction.onHaveTask(task);
}
while (!_removeTaskList.isEmpty())
{
Task task ;
synchronized (_removeTaskList)
{
task = _removeTaskList.remove(0);
}
_taskAction.onRemoveTask(task);
}
while (!_finishTaskList.isEmpty())
{
Task task ;
synchronized (_finishTaskList)
{
task = _finishTaskList.remove(0);
}
_taskAction.onFinishTask(task);
}
}

private void process() throws Exception
{
renderTask();
}
/**
* stop this thread
*
*/
public void setDone()
{
_ceased = true;
}

public boolean isDone()
{
return _ceased;
}
}

public abstract class AbstractTask extends Thread implements Task
{

private String _id;

private String _owner;

private Date _startTime;

private Date _finishTime ;

private boolean _success;

public AbstractTask()
{
//我们默认初始化了标识
_id = GUIDUtils.makeGUID();
_startTime = new Date();
_finishTime = new Date();
}
protected void setSuccess(boolean success)
{
_success = success;
}

public boolean isSuccess()
{
return _success;
}
public Date getStartTime()
{
return _startTime;
}

private void setStartTime(Date date)
{
_startTime = date;
}

public Date getFinishTime()
{
return _finishTime;
}

private void setFinishTime(Date date)
{
_finishTime = date;
}

public String getIdentity()
{
return _id;
}

public void setOwner(String owner)
{
_owner = owner;
}

public String getOwner()
{
return _owner;
}

public abstract void exec() throws Exception;

public final void run()
{
setStartTime(DateUtils.getCurrentDate());
try
{
exec();
setSuccess(true);
}catch(Exception e)
{
setSuccess(false);
e.printStackTrace();
}finally
{
setFinishTime(DateUtils.getCurrentDate());
TaskQueues.getInstance().taskFinish(this);
}
}
}

public class TaskPanel extends Window implements AfterCompose , TaskAction
{

/**
*
*/
private static final long serialVersionUID = 1L;

private Sbutton remove;
private Sbutton cancel;
private Listbox taskListbox;
private Timer taskStateCheckTimer;
private TaskMonitor taskMonitor;
public void afterCompose()
{
Components.wireVariables(this , this);

taskListbox.setItemRenderer(new TaskListitemRenderer());
taskListbox.addEventListener(Events.ON_SELECT, new EventListener(){
public void onEvent(Event event) throws Exception
{
remove.setDisabled(true);
if(taskListbox.getSelectedCount() == 0)
return;
final Listitem listitem = (Listitem) taskListbox.getSelectedItem();
final Task task = (Task) listitem.getValue();
cancel.setDisabled(!task.isAlive());
remove.setDisabled(false);
}
});
taskMonitor = new TaskMonitor(GUIDUtils.makeGUID() , LogonHelper.getLogonUserId()
, this.getDesktop() , this);
taskMonitor.start();
//initCheckTimer();
}

private void initCheckTimer()
{
taskStateCheckTimer = new Timer();
taskStateCheckTimer.setDelay(1000);
taskStateCheckTimer.setRepeats(true);
taskStateCheckTimer.addEventListener(Events.ON_TIMER, new EventListener()
{
public void onEvent(Event arg0) throws Exception
{
//当前活动的任务数
int aliveTaskCount = 0;
for(Iterator iter = taskListbox.getItems().iterator() ; iter.hasNext();)
{
final Listitem listitem = (Listitem) iter.next();
final Task task = (Task) listitem.getValue();
if(task.isAlive())
aliveTaskCount++;
if(!((Boolean)listitem.getAttribute("flag")).booleanValue()
&& task.isAlive() == false)
{
//重新渲染
taskListbox.getItemRenderer().render(listitem, task);
}
}
//发送监听
Events.postEvent("onAliveTaskCount" , TaskPanel.this, aliveTaskCount);
}
});
taskStateCheckTimer.setParent(this);
taskStateCheckTimer.start();
}
/**
* 清除所有任务(包括已完成和正在运行的)
* @param event
*/
public void onClear(Event event)
{
if(taskListbox.getItemCount() == 0)
return ;
for(Iterator iter = taskListbox.getItems().iterator() ; iter.hasNext();)
{
final Listitem listitem = (Listitem) iter.next();
final Task task = (Task) listitem.getValue();
taskMonitor.getTaskQueues().removeTask(task.getIdentity());
}
}
/**
* 删除任务
* @param event
*/
public void onRemove(Event event)
{
if(taskListbox.getSelectedCount() == 0)
return;
final Listitem listitem = taskListbox.getSelectedItem();
final Task task = (Task) listitem.getValue();
taskMonitor.getTaskQueues().removeTask(task.getIdentity());
}
/**
* 取消任务
* @param event
*/
public void onCancel(Event event)
{
if(taskListbox.getSelectedCount() == 0)
return;
final Listitem listitem = taskListbox.getSelectedItem();
final Task task = (Task) listitem.getValue();
taskMonitor.getTaskQueues().cancelTask(task.getIdentity());
}

public void onFinishTask(Task task)
{
for(Iterator iter = taskListbox.getItems().iterator() ; iter.hasNext();)
{
final Listitem listitem = (Listitem) iter.next();
final Task _task = (Task) listitem.getValue();
if(task.getIdentity().equals(_task.getIdentity()))
{
try
{
taskListbox.getItemRenderer().render(listitem, _task);
} catch (Exception e)
{
e.printStackTrace();
}
break;
}
}
}

public void onHaveTask(Task task)
{
final Listitem listitem = new Listitem();
listitem.setParent(taskListbox);
try
{
taskListbox.getItemRenderer().render(listitem , task);
} catch (Exception e)
{
e.printStackTrace();
}
//发送监听
Events.postEvent("onHaveTask", this, task);
}

public void onRemoveTask(Task task)
{
Listitem item = null;
for(Iterator iter = taskListbox.getItems().iterator() ; iter.hasNext();)
{
final Listitem listitem = (Listitem) iter.next();
final Task _task = (Task) listitem.getValue();
if(_task.getIdentity().equals(task.getIdentity()))
{
item = listitem;
break;
}
}
if(item != null)
item.detach();
//发送监听
Events.postEvent("onRemoveTask", this , task);
//重置操作按钮状态
Events.postEvent(Events.ON_SELECT , taskListbox , null);
}

private class TaskListitemRenderer implements ListitemRenderer
{
public void render(Listitem listitem , Object data) throws Exception
{
final Task task = (Task) data;
final Listcell cell0;
final Listcell cell1;
final Listcell cell2;
final Listcell cell3;
final Listcell cell4;
listitem.setHeight("22px");
if(listitem.getFirstChild() == null)
{
(cell0 = new Listcell()).setParent(listitem);
(cell1 = new Listcell()).setParent(listitem);
(cell2 = new Listcell()).setParent(listitem);
(cell3 = new Listcell()).setParent(listitem);
(cell4 = new Listcell()).setParent(listitem);
}else
{
cell0 = (Listcell) listitem.getFirstChild();
cell1 = (Listcell) listitem.getChildren().get(1);
cell2 = (Listcell) listitem.getChildren().get(2);
cell3 = (Listcell) listitem.getChildren().get(3);
cell4 = (Listcell) listitem.getChildren().get(4);
}
//任务名称
cell0.setLabel(task.getTaskName());
//开始时间
cell1.setLabel(DateUtils.format(task.getStartTime() , "HH:mm:ss"));
//完成时间
cell2.setLabel((task.isAlive() ? "" : DateUtils.format(task.getFinishTime(), "HH:mm:ss")));
//状态
cell3.setLabel(task.isAlive() ? "正在执行" : "已完成");
//操作
final Toolbarbutton tbb;
if(cell4.getFirstChild() == null)
{
tbb = new Toolbarbutton(task.getOperateName());
tbb.setParent(cell4);
tbb.addEventListener(Events.ON_CLICK, new EventListener(){
public void onEvent(Event event) throws Exception
{
task.execOperate();
}
});
}else
{
tbb = (Toolbarbutton) cell4.getFirstChild();
}
tbb.setDisabled(task.isAlive() || !task.isSuccess());
listitem.setAttribute("flag", !task.isAlive());
listitem.setValue(task);
}
}
}

public interface TaskAction
{
public void onFinishTask(Task task);
/**
* 有新的任务
* @param task
*/
public void onHaveTask(Task task);

/**
* 有任务被移出
* @param task
*/
public void onRemoveTask(Task task);
}

public class TaskScheduler extends SchedulerTask
{
private Task task;
public TaskScheduler(Task task)
{
this.task = task;
}

public void run()
{
task.start();
//取消定时任务
cancel();
}

}

public class ReportExporter extends Window
{

public void onExport(ForwardEvent event)
{
final Task task = new ReportExportTask();
task.setOwner(LogonHelper.getLogonUserId());
TaskQueues.getInstance().addTask(task);
}

private class ReportExportTask extends AbstractTask
{

public void exec() throws Exception
{
// exec the report export task
}
public void execOperate() throws Exception
{
//do the operate
}
public String getOperateName()
{
return "下载";
}

public String getTaskName()
{
return "导出" +reportFormat.getSelectedItem().getValue() + "格式报表[" + parameters.get("reportTitle") + "]";
}

}

}

but when have multi export thread is run the application is very slow