如何正確使用共享的BlockingQueue？

我有一個二叉樹，其中每個節點代表一個電子門（AND，OR，...）。我的任務是計算樹的總價值（像這樣的畫面，二叉樹）：如何正確使用共享的BlockingQueue？

tree

這是到目前爲止我的代碼（沒有線程執行）：

gate_node：

public class gate_node { 
    gate_node right_c, left_c; 
    Oprtator op; 
    int value; 
    int right_v, left_v; 

    public gate_node(gate_node right, gate_node left, Oprtator op) { 
     this.left_c = left; 
     this.right_c = right; 
     this.op = op; 
     right_v = left_v = 0; 
    } 

    void add_input(int right_v, int left_v){ 
     this.right_v=right_v; 
     this.left_v=left_v; 
    } 

    int compute(int array_index, int arr_size) { 
     /* 
     * The following use of a static sInputCounter assumes that the 
     * static/global input array is ordered from left to right, irrespective 
     * of "depth". 
     */ 

     final int left, right; 
     System.out.print(this.op+"("); 

     if (null != this.left_c) { 
      left = this.left_c.compute(array_index,arr_size/2); 
      System.out.print(","); 
     } else { 
      left = main_class.arr[array_index]; 
      System.out.print(left + ","); 
     } 

     if (null != this.right_c) { 
      right = this.right_c.compute(array_index + arr_size/2,arr_size/2); 
      System.out.print(")"); 
     } else { 
      right = main_class.arr[array_index + 1]; 

      System.out.print(right + ")"); 
     } 

     return op.calc(left, right); 
    } 
}

Oprtator：

public abstract class Oprtator { 
    abstract int calc(int x, int y); 
}

和

public class and extends Oprtator { 
    public int calc(int x, int y){ 
     return (x&y); 
    } 
}

或者

public class or extends Oprtator { 
    public int calc(int x, int y){ 
     return (x|y); 
    } 
}

樹：

public class tree implements Runnable { 
    gate_node head; 

    tree(gate_node head) { 
     this.head = head; 
    } 

    void go_right() { 
     head = head.right_c; 
    } 

    void go_left() { 
     head = head.left_c; 
    } 

    @Override 
    public void run() { 
     // TODO Auto-generated method stub 
    } 
}

主類

public class main_class { 
    public static int arr[] = { 1, 1, 0, 1, 0, 1, 0, 1 }; 

    public static void main(String[] args) { 
     tree t = new tree(new gate_node(null, null, new and())); 

     t.head.right_c = new gate_node(null, null, new or()); 

     t.head.right_c.right_c = new gate_node(null, null, new and()); 
     t.head.right_c.left_c = new gate_node(null, null, new and()); 

     t.head.left_c = new gate_node(null, null, new or()); 

     t.head.left_c.right_c = new gate_node(null, null, new and()); 
     t.head.left_c.left_c = new gate_node(null, null, new and()); 

     int res = t.head.compute(0, arr.length); 

     System.out.println(); 
     System.out.println("The result is: " + res); 
    } 
}

我要計算使用它的線程池，這樣的算法：

製備：

實現每個門作爲類/對象。它必須有2個屬性：輸入A，輸入B和計算結果的方法;
實現一棵樹。每個節點是一對（gate，next_node）。 Root是next_node爲空的節點。葉子是沒有其他節點指向它的節點。
使用共享（線程安全）節點隊列。它最初是空的。
從隊列中持續等待一個元素的線程有一個固定的數字（選擇一個，不依賴於門的數量）（除非在這種情況下他們剛剛退出）。

循環：

每當輸入把節點隊列中的節點上發生（在開始輸入到葉）。這可以通過在門上定義add_input方法來實現。
線程從隊列拾取節點：
1. 如果輸入中的一個被丟失丟棄它（第二輸入出現時它會在那裏再一次）。另一個想法是僅當兩個輸入都存在時纔將節點放入隊列中。
2. 如果兩個輸入都存在，則計算結果並將其傳遞給next_node（如果它不爲空）（並將next_node放入隊列中）。如果next_node爲null，那麼這就是你的結果 - 打破循環並最終確定。

唯一的問題是，我不知道如何創建一個共享的BlockingQueue樹中的每個節點對象可以將自己變成它，以及如何創建的固定大小的線程的數組不斷等待隊列中的新元素可用（然後執行它們）.....直到頭從列表中移除（這意味着我們正在計算）。

我在網上搜索了BlockingQueue的例子，但我只找到生產者和消費者的例子，我很難將這些例子移動到適合我的問題。如果有人能夠幫助我，我會很感激。

來源

2013-12-20 Matoy

我可以給你一些出發的指針，讓你去:)

要創建的線程只是因爲它產生的許多線程：

for (int i=0;i<MAX_THREADS;i++) { 
    new Thread(myRunnable).start(); 
}

你可能想存儲這些線程參考但它不是必需的。線程不需要特殊設置，因爲它們都是相同的，它們都只是坐在那裏抓取隊列中的物品。

要共享的阻塞隊列的最簡單的方法就是讓它靜態和決賽：

static final BlockingQueue blockingQueue();

現在所有的線程可以訪問它。

順便說一句，如果我這樣做，我根本不會使用隊列，我會使用ThreadPoolExecutor並將處理作爲新的runnables發送。

http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ThreadPoolExecutor.html

來源

2013-12-20 18:25:24

如何正確使用共享的BlockingQueue？

回答

相關問題