一種面向作業流(工作流)的輕量級可複用的異步流水開發框架JobFlow的設計與實現

一種面向作業流(工作流)的輕量級可複用的異步流水開發框架JobFlow的設計與實現

 

       要做這個東東的想法由來以久了的說，一個月以前動手把代碼實現了下來，今天覺得如果實在不寫成博文記錄下來的話，不知又要推到何年何月了。嗯，廢話不多說，直入正題了~

       在實際的開發過程中，我們經常會遇到這樣的情況：海量的併發用戶發送請求要求服務器處理，而服務器集羣之間彼此也經常會傳遞請求，用於完成特定的任務。我們可以把處理每個請求的過程理解爲是一種任務的執行，這樣的話，就相當於有一堆的作業擺在那時需要執行。而我們所要關心的是作業的數據結構是如何描述的、作業是如何存放、如何取出的以及是如何執行的。

       基於上述的思路，我們可以將任何的操作流程封裝在一個Job裏，並將其丟入到一個Job池中，Job池最好設置成阻塞模式，這樣即可喚醒等待的多個處理器從Job池中取出Job並執行。這樣一個框架的形成就牽涉到了宏觀設計的問題：即Job、Job池及處理器這三種最重要的資源是如何定義和組織的。JobFlow整體的框架結果如下圖所示：

 

爲了便於簡化開發過程，使用的開發語言爲Java，但這種設計思路是基於面向對象的，具備普適意義，感興趣的可以自己實現C++版本。代碼的組織結構截圖如下：

 

一、Job作業的設計

       Job即是對處理某個任務/作業執行流程的一種抽象，Job接口提供一個最重要的方法：run()，我們可以定義具體的Job類，實現run()方法，用於填充必要的業務邏輯，在run()執行過程中可能會產生新的Job。按照這樣的思路，我們可以在一個大Job的run()方法定義相關的執行流程，從而派生出若干個小Job，繼而實現了對一個大Job的拆分過程，同時每小Job也還可以繼續做拆分…

       如下圖所示，簡單地舉例：我們定義了加法Job、減法Job、乘法Job及除法Job，每種Job均實現了Job接口，對於run()方法做了對應的填充，分別實現了兩個數的相加、相減、相乘和相除。

 

package com.jobflow.framework; import java.io.Serializable; /** * 抽象Job接口：提供Job的業務邏輯入口和Job相關的信息 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public interface Job extends Runnable, Serializable { /** * Job執行入口，填充必要的業務邏輯，執行過程中可能產生新的任務 * */ public void run(); /** * 獲知該Job相關的信息 * * @return Job相關信息 */ public String getJobInfo(); }

二、作業池JobPool的設計

       既然生成了Job，那麼這些Job就需要進行存放。JobPool作爲Job作業存儲的載體，最爲關注的是Job的存入put()，和Job的取出get()。而Job池本身的存儲介質可以是多種多樣的：內存、數據庫或者是文件系統；Job池的取出策略也可以是多種多樣的：作業先進先出FIFO、作業先進後出FILO、大作業優先、小作業優先、響應比高者優先、隨機等等。

       由於JobPool的存儲介質和取出策略兩者是獨立的部分，使用橋接模式代替類之間的繼承關係，使這兩個部分獨立地變化，從而避免了派生類的膨脹。

爲了便於說明問題，本文後面的代碼裏只關注了取出策略的變化，存儲介質只是基於內存實現的，但這並不代表我不知道如何實現這個橋接模式。

package com.jobflow.framework; import java.io.Serializable; import java.rmi.Remote; import java.rmi.RemoteException; /** * 作業池JobPool接口：提供Job池最基本的操作，JobPool只關注業務邏輯接口，不關注Job具體的存儲介質、存取方式等 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public interface JobPool extends Remote, Serializable { /** * 獲取一個Job * * @return 一個Job */ public Job get() throws RemoteException; /** * 存放一個Job * * @param Job * 要存放的Job * @return 是否成功 */ public boolean put(Job job) throws RemoteException; /** * 批量存放Job * * @param object * 要存放的批量Job * @return 是否成功 */ public boolean putBatch(Job[] jobs) throws RemoteException; /** * 獲取Job池中Job的數目 * * @return Job池中Job數目 */ public int getNum() throws RemoteException; /** * 判斷Job池是否爲空 * * @return Job池是否爲空 */ public boolean isEmpty() throws RemoteException; /** * 判斷Job池是否滿載 * * @return Job池是否滿載 */ public boolean isFull() throws RemoteException; /** * 清空Job池 * * @return 是否清空Job池 */ public boolean clear() throws RemoteException; }

三、處理器Executer的設計

       有了Job，也有了存儲Job的JobPool，那麼我們就需要定義一些計算資源從JobPool裏出取一個Job，並執行Job.run()。我們將這種計算資源抽象爲Executer，即處理器。Executer可以是一個進程或者是一個線程，可以是本地的計算資源，也可以考慮是遠程的計算資源，這樣我們可以靈活地將單機環境的系統擴展爲一個分佈式計算系統。爲了簡單處理，我們Executer的設計先考慮本地線程的情況。

package com.jobflow.framework; /** * 抽象處理器接口：定義處理器的相關執行操作，處理器可以是單機環境的線程、進程，也可以是分佈式環境的線程、進程 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public interface Executer { /** * 處理器執行Job的接口 */ public abstract void run(); /** * 處理器開始執行 */ public abstract void start(); /** * 處理器關閉接口 */ public abstract void shutdown(); /** * 獲取處理器ID * * @return 處理器ID */ public int getExecuterId(); /** * 設置處理器ID * * @param executerId * 處理器ID */ public void setExecuterId(int executerId); /** * 獲取該處理器作用的Job池 * * @return Job池 */ public JobPool getJobPool(); /** * 爲該處理器設置對應的Job池 * * @param jobPool * Job池 */ public void setJobPool(JobPool jobPool); /** * 處理器是否正在執行 * * @return 處理器是否正在執行 */ public boolean isRunning(); /** * 設置處理器的執行狀態 * * @param isRunning * 處理器的執行狀態 */ public void setRunning(boolean isRunning); /** * 處理器是否已經關閉 * * @return 處理器是否已經關閉 */ public boolean isShutdown(); /** * 設置處理器的關閉狀態 * * @param isShutdown * 處理器的關閉狀態 */ public void setShutdown(boolean isShutdown); }

我們在使用計算資源Executer時，並非只有一個Executer，利用ExecuterPool對Executer進行管理。

 

package com.jobflow.framework; /** * 抽象處理器池接口ExecuterPool：簡單地對處理器隊列進行封裝，提供必須的操作 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public interface ExecuterPool { /** * 從處理器池中獲得處理器數組 * * @return 處理器數組 */ public Executer[] getExecuters(); /** * 獲取處理器池中最大能容納的處理器數目 * * @return 最大能容納的處理器數目 */ public int getMaxExecuterNum(); /** * 設置處理器池最大能容納的處理器數目 * * @param maxExecuterNum * 最大能容納的處理器數目 */ public void setMaxExecuterNum(int maxExecuterNum); /** * 獲取處理器池所對應的Job池 * * @return 對應的Job池 */ public JobPool getJobPool(); /** * 爲處理器池設置對應的Job池 * * @param jobPool * 對應的Job池 */ public void setJobPool(JobPool jobPool); }

爲了使計算資源也作業本身對接，我們創建一個作業池管理類JobPoolManager封裝JobPool與ExecuterPool，用於取出Job並執行。

package com.jobflow.framework; import java.rmi.RemoteException; /** * 管理作業池接口JobPoolManager：用於提供管理Job池及處理器的接口 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public interface JobPoolManager { /** * 啓動工作線程，開始處理任務 */ public void startup(); /** * 向Job池中放入新Job，託管交由Job池處理 * * @param newJob * 新Job * @throws RemoteException */ public void put(Job newJob) throws RemoteException; /** * 批量增加新Job，託管交由Job池處理 * * @param jobs * 批量Job * @throws RemoteException */ public void putBatch(Job[] jobs) throws RemoteException; /** * 獲知Job池的相關信息 * * @return Job池的相關信息 * @throws RemoteException */ public String getJobPoolInfo() throws RemoteException; /** * 停止工作線程，工作線程不一定立即停止，只有在線程處於運行狀態時會立即停止 * * @throws RemoteException */ public void shutdown() throws RemoteException; /** * 獲取所要管理的Job池 * * @return Job池 */ public JobPool getJobPool(); /** * 設置要管理的Job池 * * @param jobPool * 所要管理的Job池 */ public void setJobPool(JobPool jobPool); /** * 設置所要管理的處理器池 * * @return 所要管理的處理器池 */ public ExecuterPool getExecuters(); /** * 設置所要管理的處理器池 * * @param executers * 所要管理的處理器池 */ public void setExecuters(ExecuterPool executers); }

四、基本的實現BaseXXXX.java

有了上述這些框架基礎的接口之後，我們需要對這些接口做一些最初步的實現，稱之爲BaseXXXX.java，對應源代碼分別如下：

package com.jobflow.base; import com.jobflow.framework.impl.JobImpl; /** * 基礎工作類BaseJob：提供基本Job操作 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public abstract class BaseJob extends JobImpl { } package com.jobflow.base; import java.rmi.RemoteException; import com.jobflow.framework.impl.JobPoolImpl; /** * 基礎的Job池BaseJobPool類：提供最基本Job池的方法 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public abstract class BaseJobPool extends JobPoolImpl { /** * 默認構造函數 */ public BaseJobPool() throws RemoteException { this(MAX_JOB_NUM); } /** * 構造函數，初始化相關參數 * * @param maxJobNum * 實際Job池中所能存儲的最大Job數目 */ public BaseJobPool(int maxJobNum) throws RemoteException { this.maxJobNum = maxJobNum; } } package com.jobflow.base; import com.jobflow.framework.JobPool; import com.jobflow.framework.impl.ExecuterImpl; /** * 基礎的處理器BaseExecuter類：提供最基本處理Job的方法 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class BaseExecuter extends ExecuterImpl { /** * 構造函數 * * @param executerId * 處理器ID * @param jobPool * 所要處理的Job池 */ public BaseExecuter(int executerId, JobPool jobPool) { super(executerId, jobPool); } } package com.jobflow.base; import com.jobflow.framework.JobPool; import com.jobflow.framework.impl.ExecuterPoolImpl; /** * 基礎的處理器池類BaseExecuterPool：基本的封裝處理器隊列 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class BaseExecuterPool extends ExecuterPoolImpl { /** * 構造函數 * * @param jobPool * 設置處理器池所對應的Job池 */ public BaseExecuterPool(JobPool jobPool) { super(jobPool); } /** * 構造函數 * * @param maxExecuterNum * 能容納的最大處理器數目 * @param jobPool * 要處理的Job池 */ public BaseExecuterPool(int maxExecuterNum, JobPool jobPool) { super(maxExecuterNum, jobPool); } } package com.jobflow.base; import com.jobflow.framework.JobPool; import com.jobflow.framework.impl.ExecuterPoolImpl; import com.jobflow.framework.impl.JobPoolManagerImpl; /** * 基本的管理Job池的類BaseJobPoolMananger：用於管理Job池資源對象，並分配相應的處理器執行Job * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class BaseJobPoolManager extends JobPoolManagerImpl { /** * 構造函數 * * @param jobPool * 所要處理的Job池 * @param executerPool * 處理器池，封裝了處理器隊列 */ public BaseJobPoolManager(JobPool jobPool, ExecuterPoolImpl executerPool) { super(jobPool, executerPool); } }

五、具體的實現

基於BaseXXXX.java的基本實現，我們需要定義能夠在實際運行環境下工作的類，源代碼如下：

package com.jobflow.framework.impl; import java.util.Date; import com.jobflow.framework.Job; /** * 抽象工作類BaseJob：提供基本Job操作 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public abstract class JobImpl implements Job { /* Job的ID */ protected long id; /* Job創建時間 */ protected Date createTime = null; /* Job提交執行時間 */ protected Date submitTime = null; /* Job開始執行時間 */ protected Date beginTime = null; /* JOb執行完成時間 */ protected Date finishTime = null; /** * 默認構造函數初始化Job的創建時間 */ public JobImpl() { this.createTime = new Date(); } /** * Job執行入口，填充必要的業務邏輯，執行過程中可能產生新的任務 * */ public abstract void run(); /** * 獲知該Job相關的信息 * * @return Job相關信息 */ public String getJobInfo() { return "Job:【ID】=" + this.id + "/t【生成時間】:" + this.createTime + "/t【開始執行時間】:" + this.beginTime + "/t【執行完成時間】:" + this.finishTime; } /** * 獲取Job的ID * * @return */ public long getId() { return id; } /** * 設置Job的ID * * @param id * Job的ID */ public void setId(long id) { this.id = id; } /** * 獲取Job的創建時間 * * @return Job的創建時間 */ public Date getCreateTime() { return createTime; } /** * 設置Job的創建時間 * * @param createTime * Job的創建時間 */ public void setCreateTime(Date createTime) { this.createTime = createTime; } /** * 獲取Job的提交時間 * * @return Job的提交時間 */ public Date getSubmitTime() { return submitTime; } /** * 設置Job的提交時間 * * @param submitTime * Job的提交時間 */ public void setSubmitTime(Date submitTime) { this.submitTime = submitTime; } /** * 獲取Job開始執行的時間 * * @return Job開始執行的時間 */ public Date getBeginTime() { return beginTime; } /** * 設置Job開始執行的時間 * * @param beginTime * Job開始執行的時間 */ public void setBeginTime(Date beginTime) { this.beginTime = beginTime; } /** * 獲取Job執行結束的時間 * * @return Job執行結束的時間 */ public Date getFinishTime() { return finishTime; } /** * 設置Job執行結束的時間 * * @param finishTime * Job執行結束的時間 */ public void setFinishTime(Date finishTime) { this.finishTime = finishTime; } } package com.jobflow.framework.impl; import java.io.Serializable; import java.rmi.RemoteException; import java.rmi.server.UnicastRemoteObject; import com.jobflow.framework.Job; import com.jobflow.framework.JobPool; /** * 抽象Job池BaseJobPool類：提供最基本Job池的方法 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public abstract class JobPoolImpl extends UnicastRemoteObject implements JobPool, Serializable { /* 默認Job池中所能存儲的最大Job數目 */ protected static final int MAX_JOB_NUM = 100; /* 實際Job池中所能存儲的最大Job數目 */ protected int maxJobNum = -1; /** * 默認構造函數 */ public JobPoolImpl() throws RemoteException { this(MAX_JOB_NUM); } /** * 構造函數，初始化相關參數 * * @param maxJobNum * 實際Job池中所能存儲的最大Job數目 */ public JobPoolImpl(int maxJobNum) throws RemoteException { this.maxJobNum = maxJobNum; } /** * 批量存放Job * * @param object * 要存放的批量Job * @return 是否成功 */ public boolean putBatch(Job[] jobs) throws RemoteException { return false; } /** * 獲取Job池中Job的數目 * * @return Job池中Job數目 */ public int getNum() throws RemoteException { return -1; } /** * 同步地獲取最大能容納的Job數目 * * @return 最大能容納的Job數目 */ public synchronized int getMaxJobNum() throws RemoteException { return maxJobNum; } /** * 設置最大能容納的Job數目 * * @param maxJobNum * 最大能容納的Job數目 */ public void setMaxJobNum(int maxJobNum) throws RemoteException { this.maxJobNum = maxJobNum; } /** * 獲取默認的最大能容納的Job數目MAX_JOB_NUM * * @return 默認的最大能容納的Job數目MAX_JOB_NUM */ public static int getMAX_JOB_NUM() throws RemoteException { return MAX_JOB_NUM; } } package com.jobflow.framework.impl; import java.rmi.RemoteException; import java.util.Date; import com.jobflow.framework.Executer; import com.jobflow.framework.JobPool; /** * 處理器抽象類ExecuterImpl：以線程作爲處理器的載體，並實現了處理器Executer抽象接口 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class ExecuterImpl extends Thread implements Executer { /* 處理器的ID */ protected int executerId; /* 所作用的作業池 */ protected JobPool jobPool = null; /* 該工作線程是否正在執行 */ protected boolean isRunning = false; /* 該工作線程是否已經關閉 */ protected boolean isShutdown = false; /** * 設置處理器的ID和所要處理的Job池 * * @param executerId * 處理器ID * @param jobPool * 所要處理的Job池 */ public ExecuterImpl(int executerId, JobPool jobPool) { this.executerId = executerId; this.jobPool = jobPool; } /** * 關鍵代碼：處理Job池中的Job * */ public void run() { while (!this.isShutdown) { JobImpl job = null; /* 同步對象爲JobPool */ synchronized (jobPool) { try { while (jobPool.isEmpty()) { try { /* Job池爲空則進入等待狀態 */ jobPool.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } /* 從Job池中取出一個Job */ job = (JobImpl) jobPool.get(); } catch (RemoteException e) { e.printStackTrace(); } } if (null != job) { /* 設置忙碌狀態 */ this.isRunning = true; /* 設置Job開始執行時間 */ job.setBeginTime(new Date()); /* 執行Job */ new Thread(job).start(); /* 設置Job執行完畢的時間 */ job.setFinishTime(new Date()); /* 處理器重新處於等待狀態 */ this.isRunning = false; /* 打印出Job的相關信息 */ System.out.println(job.getJobInfo()); /* 清除處理後的Job */ job = null; } } } /** * 設置處理器爲關閉狀態 */ public void shutdown() { this.setShutdown(true); } /** * 獲取處理器ID * * @return 處理器ID */ public int getExecuterId() { return executerId; } /** * 設置處理器ID * * @param executerId * 處理器ID */ public void setExecuterId(int executerId) { this.executerId = executerId; } /** * 獲取該處理器作用的Job池 * * @return Job池 */ public JobPool getJobPool() { return jobPool; } /** * 爲該處理器設置對應的Job池 * * @param jobPool * Job池 */ public void setJobPool(JobPool jobPool) { this.jobPool = jobPool; } /** * 處理器是否正在執行 * * @return 處理器是否正在執行 */ public boolean isRunning() { return isRunning; } /** * 設置處理器的執行狀態 * * @param isRunning * 處理器的執行狀態 */ public void setRunning(boolean isRunning) { this.isRunning = isRunning; } /** * 處理器是否已經關閉 * * @return 處理器是否已經關閉 */ public boolean isShutdown() { return isShutdown; } /** * 設置處理器的關閉狀態 * * @param isShutdown * 處理器的關閉狀態 */ public void setShutdown(boolean isShutdown) { this.isShutdown = isShutdown; } } package com.jobflow.framework.impl; import com.jobflow.framework.Executer; import com.jobflow.framework.ExecuterPool; import com.jobflow.framework.JobPool; /** * 抽象處理器池類ExecuterPoolImpl：簡單地對處理器隊列進行封裝 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class ExecuterPoolImpl implements ExecuterPool { /* 默認處理器池中所能存儲的最大處理器數目 */ protected static final int MAX_EXECUTER_NUM = 10; /* 實際處理器池中所能存儲的最大處理器數目 */ protected int maxExecuterNum = 0; /* 處理器所處理的Job池 */ protected JobPool jobPool = null; /* 處理器隊列 */ protected Executer[] executers = null; /** * 構造函數 * * @param jobPool * 所要處理的Job池 */ public ExecuterPoolImpl(JobPool jobPool) { this(MAX_EXECUTER_NUM, jobPool); } /** * 構造函數，初始化相關參數 * * @param maxExecuterNum * 實際Job池中所能存儲的最大Job數目 * @param jobPool * 所要處理的Job池 */ public ExecuterPoolImpl(int maxExecuterNum, JobPool jobPool) { this.maxExecuterNum = maxExecuterNum; this.jobPool = jobPool; this.init(); } /** * 初始化處理器 */ public void init() { /* 必須先爲數組申請存儲空間，否則會出現空指針異常 */ executers = new Executer[maxExecuterNum]; /* 遍歷初始化處理器 */ for (int index = 0; index < maxExecuterNum; ++index) { this.executers[index] = new ExecuterImpl(index + 1, jobPool); } } /** * 從處理器池中獲得處理器數組 * * @return 處理器數組 */ public Executer[] getExecuters() { /* 如果處理器隊列爲空，則調用init()函數初始化處理器隊列 */ if (null == executers) { this.init(); } return this.executers; } /** * 獲取處理器池中最大能容納的處理器數目 * * @return 最大能容納的處理器數目 */ public int getMaxExecuterNum() { return maxExecuterNum; } /** * 設置處理器池最大能容納的處理器數目 * * @param maxExecuterNum * 最大能容納的處理器數目 */ public void setMaxExecuterNum(int maxExecuterNum) { this.maxExecuterNum = maxExecuterNum; } /** * 默認的處理器池所容納最大數目MAX_EXECUTER_NUM * * @return 默認的處理器池所容納最大數目MAX_EXECUTER_NUM */ public static int getMAX_EXECUTER_NUM() { return MAX_EXECUTER_NUM; } /** * 獲取處理器池所對應的Job池 * * @return 對應的Job池 */ public JobPool getJobPool() { return jobPool; } /** * 爲處理器池設置對應的Job池 * * @param jobPool * 對應的Job池 */ public void setJobPool(JobPool jobPool) { this.jobPool = jobPool; } /** * 設置處理器數組 * * @param executers * 處理器數組 */ public void setExecuters(Executer[] executers) { this.executers = executers; } } package com.jobflow.framework.impl; import java.rmi.RemoteException; import com.jobflow.framework.Executer; import com.jobflow.framework.ExecuterPool; import com.jobflow.framework.Job; import com.jobflow.framework.JobPool; import com.jobflow.framework.JobPoolManager; /** * 管理作業池抽象類JobPoolManagerImpl：用於管理Job池及處理器 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class JobPoolManagerImpl implements JobPoolManager { /* Job池的存儲載體 */ protected JobPool jobPool = null; /* 處理器隊列 */ protected ExecuterPool executers = null; /** * 構造函數，指定對應的Job池和處理器隊列 * * @param jobPool * 要處理的Job池 * @param executers * 用於執行的處理器隊列 */ public JobPoolManagerImpl(JobPool jobPool, ExecuterPool executers) { this.jobPool = jobPool; this.executers = executers; /* 啓動處理器 */ // this.startup(); } /** * 啓動工作線程，開始處理任務 */ public void startup() { System.out.println("正在啓動處理器..."); /* 啓動處理器工作 */ for (Executer executer : executers.getExecuters()) { executer.start(); } } /** * 向Job池中放入新Job，託管交由Job池處理 * * @param newJob * 新Job * @throws RemoteException */ public void put(Job newJob) throws RemoteException { System.out.println("往Job池中放入一個新Job..."); jobPool.put(newJob); } /** * 批量增加新Job，託管交由Job池處理 * * @param jobs * 批量Job * @throws RemoteException */ public void putBatch(Job[] jobs) throws RemoteException { System.out.println("往Job池中放入批量放入新Job..."); jobPool.putBatch(jobs); } /** * 獲知Job池的相關信息 * * @return Job池的相關信息 * @throws RemoteException */ public String getJobPoolInfo() throws RemoteException { StringBuffer stringBuffer = new StringBuffer(); stringBuffer.append("Job池中尚未處理的Job數目：" + jobPool.getNum() + "/n"); for (Executer executer : executers.getExecuters()) { stringBuffer.append("處理器【" + executer.getExecuterId() + "】正在" + ((executer.isRunning()) ? "運行..." : "等待.../n")); } return stringBuffer.toString(); } /** * 停止工作線程，工作線程不一定立即停止，只有在線程處於運行狀態時會立即停止 * * @throws RemoteException */ public synchronized void shutdown() throws RemoteException { System.out.println("正在停止處理器..."); /* 關閉處理器 */ for (Executer executer : executers.getExecuters()) { executer.shutdown(); executer = null; } /* 清空Job池 */ jobPool.clear(); System.out.println("處理器已經全部停止，Job池已經清空..."); } /** * 獲取所要管理的Job池 * * @return Job池 */ public JobPool getJobPool() { return jobPool; } /** * 設置要管理的Job池 * * @param jobPool * 所要管理的Job池 */ public void setJobPool(JobPool jobPool) { this.jobPool = jobPool; } /** * 設置所要管理的處理器池 * * @return 所要管理的處理器池 */ public ExecuterPool getExecuters() { return executers; } /** * 設置所要管理的處理器池 * * @param executers * 所要管理的處理器池 */ public void setExecuters(ExecuterPool executers) { this.executers = executers; } }

 

六、基於隊列的JobPool實現

我們現在可以自己定義具體的Job存取方式了，如以List隊列形式存放Job會遵循FIFO的取出規則：

package com.jobflow.impl; import java.rmi.RemoteException; import java.util.Collections; import java.util.Date; import java.util.LinkedList; import java.util.List; import com.jobflow.base.BaseJob; import com.jobflow.base.BaseJobPool; import com.jobflow.framework.Job; /** * List形式的Job池類ListJobPool：以List形式爲載體的Job池實現 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class ListJobPool extends BaseJobPool { /* Job池的序列號ID號 */ private static final long serialVersionUID = -6236080833979961860L; /* 用於標識Job的ID */ private long jobCounter = 0; /* Job池存儲的載體 */ private List<Job> jobList = Collections .synchronizedList(new LinkedList<Job>()); /** * 默認構造函數 */ public ListJobPool() throws RemoteException { super(); } /** * 構造函數，初始化相關參數 * * @param maxJobNum * 實際Job池中所能存儲的最大Job數目 */ public ListJobPool(int maxJobNum) throws RemoteException { super(maxJobNum); } /** * 從Job池中取出一個Job * * @param 一個Job */ public Job get() throws RemoteException { synchronized (this) { return jobList.remove(0); } } /** * 向Job池中放入新Job * * @param newJob * 新Job */ public boolean put(Job newJob) throws RemoteException { synchronized (this) { /* 強制使用BaseJob類型，設置Job的相關屬性 */ ((BaseJob) newJob).setId(++jobCounter); ((BaseJob) newJob).setSubmitTime(new Date()); /* 放入Job池 */ jobList.add(newJob); /* 喚醒Job池，開始執行Job */ jobList.notifyAll(); return true; } } /** * 批量增加新Job * * @param jobs * 批量Job */ public boolean putBatch(Job[] jobs) throws RemoteException { /* 作業隊列爲空則返回 */ if (null == jobs || jobs.length == 0) { return false; } /* 同步對象爲封裝了Job隊列的ListJobPool */ synchronized (this) { /* 遍歷將Job依次放入Job池中 */ for (int i = 0; i < jobs.length; ++i) { if (null == jobs[i]) { continue; } /* 設置Job相關屬性信息 */ ((BaseJob) jobs[i]).setId(++jobCounter); ((BaseJob) jobs[i]).setSubmitTime(new Date()); /* 將該Job放入Job池中 */ jobList.add(jobs[i]); } /* 喚醒Job池，開始執行 */ this.notifyAll(); return true; } } /** * 獲取Job池中Job的數目 * * @return Job池中Job數目 */ public int getNum() throws RemoteException { synchronized (this) { return jobList.size(); } } /** * Job池是否爲空 * * @return Job池是否爲空 */ public boolean isEmpty() throws RemoteException { synchronized (this) { return jobList.isEmpty(); } } /** * Job池是否已滿 * * @return Job池是否已滿 */ public boolean isFull() throws RemoteException { synchronized (this) { return jobList.size() >= this.getMaxJobNum(); } } /** * Job池是已清空 * * @return Job池是已清空 */ public boolean clear() throws RemoteException { synchronized (this) { jobList.clear(); return true; } } /** * 獲取Job的總數目 * * @return Job的總數目 */ public synchronized long getJobCounter() throws RemoteException { return jobCounter; } /** * 設置Job的總數目 * * @param jobCounter * Job的總數目 */ public synchronized void setJobCounter(long jobCounter) throws RemoteException { this.jobCounter = jobCounter; } /** * 獲取Job的隊列 * * @return Job隊列 */ public synchronized List<Job> getJobList() throws RemoteException { return jobList; } /** * 設置Job隊列 * * @param jobList */ public synchronized void setJobList(List<Job> jobList) throws RemoteException { this.jobList = jobList; } }

七、單機環境測試

爲了對框架本身進行簡單的測試，我們編寫了4個簡單的Job作業，分別做加減乘除運算，並編寫了一個Test類用於框架的執行：

package com.jobflow.test; import com.jobflow.base.BaseJob; /** * 簡單的工作類JobA：實現兩個隨機數的+運算 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class JobA extends BaseJob { /* 序列化的ID號 */ private static final long serialVersionUID = -8497864829928543297L; /* 操作數1 */ private int num1 = (int) (Math.random() * 100); /* 操作數2 */ private int num2 = (int) (Math.random() * 100); /** * Job執行入口 */ public void run() { int result = num1 + num2; System.out.println(num1 + "+" + num2 + "=" + result); } /** * 基本set、get方法 * * @return */ public int getNum1() { return num1; } public void setNum1(int num1) { this.num1 = num1; } public int getNum2() { return num2; } public void setNum2(int num2) { this.num2 = num2; } } package com.jobflow.test; import com.jobflow.base.BaseJob; /** * 簡單的工作類JobB：實現兩個隨機數的-運算 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class JobB extends BaseJob { /* 序列化的ID號 */ private static final long serialVersionUID = -344356077313636718L; /* 操作數1 */ private int num1 = (int) (Math.random() * 100); /* 操作數2 */ private int num2 = (int) (Math.random() * 100); /** * Job執行入口 */ public void run() { int result = num1 + num2; System.out.println(num1 + "-" + num2 + "=" + result); } /** * 基本set、get方法 * * @return */ public int getNum1() { return num1; } public void setNum1(int num1) { this.num1 = num1; } public int getNum2() { return num2; } public void setNum2(int num2) { this.num2 = num2; } } package com.jobflow.test; import com.jobflow.base.BaseJob; /** * 簡單的工作類JobC：實現兩個隨機數的*運算 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class JobC extends BaseJob { /* 序列化的ID號 */ private static final long serialVersionUID = 4680511842453574631L; /* 操作數1 */ private int num1 = (int) (Math.random() * 100); /* 操作數2 */ private int num2 = (int) (Math.random() * 100); /** * Job執行入口 */ public void run() { int result = num1 + num2; System.out.println(num1 + "*" + num2 + "=" + result); } /** * 基本set、get方法 * * @return */ public int getNum1() { return num1; } public void setNum1(int num1) { this.num1 = num1; } public int getNum2() { return num2; } public void setNum2(int num2) { this.num2 = num2; } } package com.jobflow.test; import com.jobflow.base.BaseJob; /** * 簡單的工作類JobD：實現兩個隨機數的/運算 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class JobD extends BaseJob { /* 序列化的ID號 */ private static final long serialVersionUID = -5806851570931840024L; /* 操作數1 */ private int num1 = (int) (Math.random() * 100); /* 操作數2 */ private int num2 = (int) (Math.random() * 100); /** * Job執行入口 */ public void run() { int result = num1 + num2; System.out.println(num1 + "/" + num2 + "=" + result); } /** * 基本set、get方法 * * @return */ public int getNum1() { return num1; } public void setNum1(int num1) { this.num1 = num1; } public int getNum2() { return num2; } public void setNum2(int num2) { this.num2 = num2; } } package com.jobflow.test; import java.rmi.RemoteException; import com.jobflow.base.BaseExecuterPool; import com.jobflow.base.BaseJobPoolManager; import com.jobflow.framework.Job; import com.jobflow.framework.JobPool; import com.jobflow.framework.impl.ExecuterPoolImpl; import com.jobflow.framework.impl.JobPoolManagerImpl; import com.jobflow.impl.ListJobPool; /** * 異步工作流測試類Test：對異步工作流的實現進行測試 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class Test { /** * 測試主函數入口 * * @param args */ public static void main(String[] args) throws RemoteException { /* Job數目 */ final int JOB_NUM = 40; /* 批量Job */ Job[] jobs = new Job[JOB_NUM]; /* 初始化Job隊列 */ for (int index = 0; index < JOB_NUM; index += 4) { jobs[index] = new JobA(); jobs[index + 1] = new JobB(); jobs[index + 2] = new JobC(); jobs[index + 3] = new JobD(); } /* 生成Job池，並將Job批量放入Job池中 */ JobPool jobPool = new ListJobPool(); /* 初始化處理器池 */ ExecuterPoolImpl executers = new BaseExecuterPool(5, jobPool); /* 生成Job池管理者，分配處理器執行Job */ JobPoolManagerImpl jobPoolManager = new BaseJobPoolManager(jobPool, executers); /* 通過管理者向Job池中添加Job */ jobPoolManager.putBatch(jobs); /* 啓動處理器 */ jobPoolManager.startup(); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } /* 關閉Job池 */ jobPoolManager.shutdown(); } } 往Job池中放入批量放入新Job... 正在啓動處理器... 72+28=100 83*90=173 82/70=152 83-14=97 90+64=154 Job:【ID】=1 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=6 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=7 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=8 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=4 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=2 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 87-20=107 36/36=72 Job:【ID】=5 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 82*60=142 Job:【ID】=9 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 18+71=89 Job:【ID】=3 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=11 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=13 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=12 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=10 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 57/17=74 87*61=148 96+26=122 Job:【ID】=15 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 7*15=22 Job:【ID】=14 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=16 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=17 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 23-93=116 62-5=67 82/48=130 56+11=67 Job:【ID】=18 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=20 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=21 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=24 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=23 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=25 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 15-85=100 75/37=112 Job:【ID】=26 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 74+3=77 3/67=70 35-75=110 Job:【ID】=19 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 39*98=137 91-43=134 15*71=86 16+72=88 Job:【ID】=22 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=27 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 43/47=90 35*60=95 Job:【ID】=28 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=30 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=29 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 44-85=129 Job:【ID】=31 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=32 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 23*38=61 1/90=91 52+84=136 65+92=157 Job:【ID】=34 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=33 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 34-18=52 98*61=159 Job:【ID】=35 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=36 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 44-36=80 3/48=51 Job:【ID】=38 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=37 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 30*70=100 85+82=167 91/58=149 Job:【ID】=40 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 Job:【ID】=39 【生成時間】:Sat May 14 08:55:34 CST 2011 【開始執行時間】:Sat May 14 08:55:38 CST 2011 【執行完成時間】:Sat May 14 08:55:38 CST 2011 正在停止處理器... 處理器已經全部停止，Job池已經清空...

八、將JobFlow的應用擴展到分佈式環境

目前而言，我們已經初步實現了單機環境下的異步工作流執行，我們更希望是將其擴展到一個分佈式的環境中，利用多物理處理機異步地執行整個工作流序列。設計的思想是將JobPool所封裝的Job隊列設置爲分佈式環境下共享的阻塞隊列，如果JobPool爲空，則所有處理器均處於阻塞狀態，如果有Job存入JobPool，則喚醒等待的處理器進行異步地執行。在編碼實現上，利用Java的RMI技術實現JobPool的遠程調用。

package com.jobflow.rmi; import java.net.MalformedURLException; import java.rmi.Naming; import java.rmi.RemoteException; import java.rmi.registry.LocateRegistry; import com.jobflow.framework.JobPool; import com.jobflow.impl.ListJobPool; /** * 啓動遠程Job池對象類RmiJobPool：在服務器端部署遠程的Job池對象 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class RmiJobPoolInit { /** * 遠程Job池對象註冊函數入口 * * @param args */ public static void main(String[] args) { try { /* 註冊一個端口號 */ LocateRegistry.createRegistry(8808); /* 啓動一個處理器 */ JobPool jobPool = new ListJobPool(); /* 綁定服務的URL */ Naming.rebind("//localhost:8808/JOB-POOL", jobPool); System.out.println("Job池已經初始化完成，等待Job的填入與取出..."); } catch (RemoteException e) { e.printStackTrace(); } catch (MalformedURLException e) { e.printStackTrace(); } } } package com.jobflow.rmi; import java.net.MalformedURLException; import java.rmi.Naming; import java.rmi.NotBoundException; import java.rmi.RemoteException; import com.jobflow.framework.Job; import com.jobflow.framework.JobPool; import com.jobflow.test.JobA; import com.jobflow.test.JobB; import com.jobflow.test.JobC; import com.jobflow.test.JobD; /** * 生產Job類RmiJobProducer：不斷地生產出Job，並填入遠程的Job池中 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class RmiJobProducer { /** * 生產Job主函數入口 * * @param args */ public static void main(String[] args) throws RemoteException { /* Job數目 */ final int JOB_NUM = 40; /* 批量Job */ Job[] jobs = new Job[JOB_NUM]; /* 初始化Job隊列 */ for (int index = 0; index < JOB_NUM; index += 4) { jobs[index] = new JobA(); jobs[index + 1] = new JobB(); jobs[index + 2] = new JobC(); jobs[index + 3] = new JobD(); } try { /* 利用RMI獲取遠程Job池對象，並將Job批量放入Job池中 */ JobPool jobPool = (JobPool) Naming .lookup("//localhost:8808/JOB-POOL"); /* 通過管理者向Job池中添加Job */ jobPool.putBatch(jobs); System.out.println("批量作業已經填入遠程Job池..."); } catch (MalformedURLException e) { e.printStackTrace(); } catch (NotBoundException e) { e.printStackTrace(); } } } package com.jobflow.rmi; import java.net.MalformedURLException; import java.rmi.Naming; import java.rmi.NotBoundException; import java.rmi.RemoteException; import com.jobflow.base.BaseExecuterPool; import com.jobflow.base.BaseJobPoolManager; import com.jobflow.framework.JobPool; import com.jobflow.framework.impl.ExecuterPoolImpl; import com.jobflow.framework.impl.JobPoolManagerImpl; /** * 執行Job的處理器類RmiExecuterServer：不斷從遠程的Job池中取出Job並執行 * * Email:[e-mail] * * @author MONKEY.D.MENG 2011-04-06 * */ public class RmiExecuterServer { /** * 處理器類入口函數 * * @param args */ public static void main(String[] args) throws RemoteException { /* 利用RMI獲取遠程Job池對象，並將Job批量放入Job池中 */ JobPool jobPool; try { jobPool = (JobPool) Naming.lookup("//localhost:8808/JOB-POOL"); /* 初始化處理器池 */ ExecuterPoolImpl executers = new BaseExecuterPool(5, jobPool); /* 生成Job池管理者，分配處理器執行Job */ JobPoolManagerImpl jobPoolManager = new BaseJobPoolManager(jobPool, executers); /* 啓動執行Job的處理器 */ jobPoolManager.startup(); } catch (MalformedURLException e) { e.printStackTrace(); } catch (NotBoundException e) { e.printStackTrace(); } } } Job池已經初始化完成，等待Job的填入與取出... 批量作業已經填入遠程Job池... 正在啓動處理器... 69+88=157 4-94=98 Job:【ID】=2 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=1 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=3 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 55*0=55 12/41=53 Job:【ID】=4 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=5 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 73+52=125 Job:【ID】=6 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 35-60=95 Job:【ID】=7 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 27*47=74 Job:【ID】=8 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 57/88=145 Job:【ID】=9 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 92+87=179 Job:【ID】=10 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 4-70=74 Job:【ID】=11 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 36*59=95 Job:【ID】=12 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 82/90=172 Job:【ID】=13 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 44+50=94 Job:【ID】=14 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 20-48=68 Job:【ID】=15 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 43*41=84 Job:【ID】=16 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 38/21=59 Job:【ID】=17 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 13+82=95 Job:【ID】=18 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 49-76=125 Job:【ID】=19 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 35*50=85 Job:【ID】=21 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=22 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=23 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=20 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 16+33=49 67*96=163 29/91=120 90-41=131 Job:【ID】=25 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=26 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=27 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 50+64=114 38*21=59 Job:【ID】=24 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 47-65=112 30/3=33 11/36=47 5-69=74 75*52=127 Job:【ID】=31 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 64+62=126 Job:【ID】=28 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=30 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=29 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=32 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 5/49=54 Job:【ID】=33 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 70+64=134 Job:【ID】=35 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=36 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 Job:【ID】=34 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 16*1=17 52/27=79 14-94=108 Job:【ID】=37 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 2+4=6 Job:【ID】=38 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 38-76=114 Job:【ID】=39 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 54*56=110 Job:【ID】=40 【生成時間】:Sat May 14 09:11:05 CST 2011 【開始執行時間】:Sat May 14 09:11:12 CST 2011 【執行完成時間】:Sat May 14 09:11:12 CST 2011 2/12=14

運行的方式：先運行RmiJobPoolInit使JobPool遠程對象化，從而適用於分佈式環境下併發的訪問，再在同一主控節點上運行RmiJobProducer產生若干Job並將這些Job放入到JobPool中。隨後，在其他從屬節點上運行RmiExecuterServer用於從JobPool中取出Job並執行，從而實現了一個簡單的分佈式計算框架。

       然而，這裏會存在一個問題，即如果你在從屬節點上先開啓RmiExecuterServer，而主控節點後開啓RmiJobProducer，則從屬節點還是一直處於阻塞狀態，並不會從JobPool中取Job執行，很奇怪呢。這裏Job的同步的控制並不完備，神馬原因呢，暫時還沒想通，以後我得找時間好好去調調~

      

九、總結

很明顯可以看出，整個JobFlow的框架的思想精髓的實質即是我們之前所學習的操作系統的兩個經典問題：生產者/消費者問題、作業調度問題。JobFlow適用於很多的場合，比如C/S模式的網絡收發數據包：網絡數據都需要經過打包、發包、解包、執行這四個流程，我們就可以將它們封裝成一個一個的Job，丟到一個很大的Job池裏面。Client端有多個打包線程不斷地將數據打包後丟到Job池中，又有多個發送線程去Job池裏取包向Server發送數據；Server端有多個接包線程在接收到Client所傳輸的數據包後，丟到自己Job池中，再由多個解析線程取Job進行數據包的解析，最後將解析後的Job分類，丟給相應的執行Job池中，再分別由多個執行線程從對應的執行Job池中取Job進行執行。

這裏只是舉例說明，具體的JobFlow的實現還是會遇到很多技術難點，要考慮各種Executer的同步、內存泄露問題、線程安全問題、各種池化對象的維護與管理。而對於一個框架而言，可擴展性、可複用性和靈活可配置性都是要考慮的問題。

       好了，JobFlow的原理和代碼實現大概就是如此了。爲了驗證想法，這個版本JobFlow的代碼實現的還是過於簡單了些，在最初設計上的考慮，在本版本的代碼裏並未。更爲完善的版本會在後續的時間裏更新，請大家持續關注本博客~