寫一個簡單的工作流（三）

上午測試了下并發情況下的表現，測試場景：一個有20個節點，包括選擇、順序、并行路由的流程，所有節點都設定為自動執行，1000個線程并發啟動案例，也就是這個流程同時有1000個案例在跑，全部跑完結果差強人意，比單線程慢了接近30倍。仔細調整了算法和加鎖粒度，盡管整體性能有所提高，但是多線程和單線程間執行的差距仍然沒有多大變化，性能瓶頸還是在核心的排程算法上，還需要分析下。測試程式如下：

package net.rubyeye.insect.workflow.test;

import java.util.arraylist;

import java.util.list;

import java.util.concurrent.cyclicbarrier;

import net.rubyeye.insect.workflow.place;

import net.rubyeye.insect.workflow.token;

import net.rubyeye.insect.workflow.transition;

import net.rubyeye.insect.workflow.workflow;

import net.rubyeye.insect.workflow.workflowmanager;

import net.rubyeye.insect.workflow.basic.basicworkflowmanager;

import net.rubyeye.insect.workflow.comm.transitiontype;

import net.rubyeye.insect.workflow.config.defaultconfiguration;

import junit.framework.testcase;

public class compositeprocesstest extends testcase {

    private workflowmanager wm;

    workflow composite;

    private cyclicbarrier barrier;

    private static final int total = 1000;

    @override

    protected void setup() throws exception {

        this.barrier = new cyclicbarrier(total + 1);

        wm = new basicworkflowmanager();

        wm.setconfiguration(new defaultconfiguration());

        workflow sequence = wm.getworkflow("sequence");

        workflow concurrency = wm.getworkflow("concurrency");

        workflow choose = wm.getworkflow("choose");

        // 組合流程

        composite = new workflow();

        composite.setname("composite");

        composite.setid(100);

        wm.saveworkflow(composite);

        // 修改開始結束節點的輸入輸出庫所

        sequence.getend().settype(transitiontype.normal);

        sequence.getend().setoutputs(concurrency.getstart().getinputs());

        concurrency.getend().settype(transitiontype.normal);

        concurrency.getend().setoutputs(choose.getstart().getinputs());

        composite.setstart(sequence.getstart());

        composite.setend(choose.getend());

        list<transition> transitions = new arraylist<transition>();

        transitions.addall(sequence.gettransitions());

        transitions.addall(concurrency.gettransitions());

        transitions.addall(choose.gettransitions());

        composite.settransitions(transitions);

    }

    public void testconcurrencycompositeprocesss() throws exception {

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

            new flowthread().start();

        }

        barrier.await();

        long start = system.currenttimemillis();

        long end = system.currenttimemillis();

        system.out.println("建立" + total + "個流程并發運作完畢\n花費時間:" + (end - start)

                / 1000.0 + "秒");

        for (transition transition : composite.gettransitions()) {

            system.out.println(transition.getname() + "  "

                    + transition.isenable());

            for (place place : transition.getoutputs()) {

                system.out.println("place " + place.getid() + " "

                        + place.gettokens().size());

            }

    public void testcompositeprocesss() throws exception {

            token token1 = wm.startworkflow("composite");

            token1.setattribute("name", "dennis");

            token1.setattribute("num", 21);

            wm.doaction(token1.getid());

            asserttrue(token1.isfinished());

        system.out.println("建立" + total + "個流程運作完畢\n花費時間:" + (end - start)

    class flowthread extends thread {

        @override

        public void run() {

            try {

                barrier.await();

                // wm = new basicworkflowmanager();

                token token1 = wm.startworkflow("composite");

                token1.setattribute("name", "dennis");

                token1.setattribute("num", 21);

                wm.doaction(token1.getid());

                asserttrue(token1.isfinished());

            } catch (exception e) {

                throw new runtimeexception(e);

}

文章轉自莊周夢蝶  ，原文釋出時間 2007-10-12