[問題] 請問有辦法設定編號來決定排程嗎

[PTTCATKING (懷念美國貓王)]

假設有二十個任務要跑

而他在DB裡會有兩組編號(欄位名稱)

第一組是1~20的流水號

第二組是執行優先順序(記錄需等待的對象)

A 跑完 同時執行 B & CD 兩條線同時跑，而B會先跑完，但要等CD都跑完後，BCD都結束
才開始跑E

A的編號就是  1  0 (無等待對象)

B的編號就是  2  1 (等待A，1是A的編號)

C的編號就是  3  1 (等待A，1是A的編號)

D的編號就是  4  3 (等待C，3是C的編號)

E的編號就是  5  2 (等待B，2是B的編號)

E的編號就是  5  4 (等待D，4是D的編號)

因為E要等兩個，所以在DB裡 E 會有兩筆資料


請問 有沒有什麼現有套件有能夠執行這件事情呢

設定那兩個編號，則程式執行後就按照兩個編號，決定程式優先順序，並有可能同時執行
多程序

以後維護就是設定編號就能決定跑程式的優先順序


今天用CountDownLatch寫出類似的東西，被認為是寫死的東西orz

這是用排程器???或是什麼方向呢?? @O@

能否有高手指點明燈給我方向，謝謝  T_T

--
※ 發信站: 批踢踢實業坊(ptt.cc), 來自: 42.66.159.143
※ 文章網址: http://www.ptt.cc/bbs/java/M.1415774748.A.B71.html
→ swpoker: 我想是你程式寫法的問題~先把你CODE放上來吧
        final CountDownLatch beginA = new CountDownLatch(1);
        final CountDownLatch end = new CountDownLatch(2);
        final CountDownLatch endE = new CountDownLatch(1);
        final ExecutorService exec = Executors.newFixedThreadPool(3);
        Runnable runA = new Runnable() {
            public void run() {
                try {
                         System.out.println("Thread A 開始..");
                    for(int i = 0; i < 5; i++) {
                        Thread.sleep(1000);
                        System.out.println("Thread A 執行..");
                    }
                    System.out.println("Thread A 即將結束..");
                    Thread.sleep((long) (Math.random() * 10000));
                } catch (InterruptedException e) {
                } finally {
                        beginA.countDown();
                }
            }
        };
        Runnable runB = new Runnable() {
            public void run() {
                try {
                        beginA.await();
                        System.out.println("Thread B 開始..");
                    for(int i = 0; i < 5; i++) {
                        Thread.sleep(1000);
                        System.out.println("Thread B 執行..");
                    }
                    System.out.println("Thread B 即將結束..");
                    Thread.sleep((long) (Math.random() * 10000));
                } catch (InterruptedException e) {
                } finally {
                    end.countDown();
                }
            }
        };
        Runnable runC = new Runnable() {
            public void run() {
                try {
                        beginA.await();
                        System.out.println("Thread C 開始..");
                    for(int i = 0; i < 5; i++) {
                        Thread.sleep(1000);
                        System.out.println("Thread C 執行..");
                    }
                    System.out.println("Thread C 即將結束..");
                    System.out.println("Thread D 開始..");
                    for(int i = 0; i < 5; i++) {
                        Thread.sleep(1000);
                        System.out.println("Thread D 執行..");
                    }
                    System.out.println("Thread D 即將結束..");
                    Thread.sleep((long) (Math.random() * 10000));
                } catch (InterruptedException e) {
                } finally {
                    end.countDown();
                }
            }
        };
        Runnable runE = new Runnable() {
            public void run() {
                try {
                        end.await();
                        System.out.println("Thread E 開始..");
                    for(int i = 0; i < 5; i++) {
                        Thread.sleep(1000);
                        System.out.println("Thread E 執行..");
                    }
                    System.out.println("Thread E 即將結束..");
                    Thread.sleep((long) (Math.random() * 10000));
                } catch (InterruptedException e) {
                } finally {
                        endE.countDown();
                }
            }
        };
        exec.submit(runA);
        exec.submit(runB);
        exec.submit(runC);
        exec.submit(runE);
        try {
                endE.await();
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        exec.shutdown();
※ 編輯: PTTCATKING (42.66.159.143), 11/12/2014 14:59:15

這樣寫大概就是 A跑完後開始跑 B跟C ，C跑完跑D ，BCD都跑完最後才跑E

只是實際上的需求是要用資料庫裡 兩個編號來決定優先順序

而修改第兩個編號可能每隻程式的執行順序就會改變

跪求神手指點名燈 T_T
※ 編輯: PTTCATKING (42.66.159.143), 11/12/2014 17:40:05
→ ssccg: 有一定要先開跑再wait再那邊的理由嗎?
→ ssccg: 前一個跑完後select出所有該接它後面跑的來跑不行?
推 yyc1217: 有點類似無限狀態機(FSM)的感覺
→ yyc1217: 另外用一個singleton的manager來做state之間的管理?
→ luoqr: 跑完的去通知在等他的那些人開動不行嗎? :S
→ carylorrk: FSM(finite state mahine)不是有限狀態機嗎 XDD
推 yyc1217: 對不起記錯了.....