Есть следующий класс реализующий интерфейс Runnable:
| Java |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
| public class TreeHandler implements Runnable {
private String name;
private JTree tree;
private Tree model;
public TreeHandler(String name, JTree tree) {
this.name = name;
this.tree = tree;
model = (Tree)tree.getModel();
}
@Override
public void run() {
Node node;
String nodeName;
int nodeNum;
int fibonacci;
System.out.println(name + " started");
while (true) {
System.out.println(name + " want to find node for handling");
synchronized (tree) {
while (true) {
Node root = (Node)(model.getRoot());
if (root == null || !isNumber(root)) {
System.out.println(name + " ended job");
return;
}
System.out.println(name + " get tree and searching...");
node = model.findNode(root, tester);
if (node != null)
break;
System.out.println("For that time there are no nodes, " + name + " waiting...");
try {
tree.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(name + " found node " + node);
nodeName = node.toString();
nodeNum = Integer.parseInt(nodeName);
model.setData(node, this.name + " start with " + nodeName);
updateTree();
}
System.out.println(name + " handling " + nodeName);
nodeNum = (int)(nodeNum > 47 ? 47-Math.random() * 7 : nodeNum < 20 ? 20 : nodeNum);
fibonacci = fibo(nodeNum);
System.out.println(name + " handled " + nodeName);
synchronized (tree) {
model.setData(node, name + " finished with " + nodeName + " with fibonacci = " + fibonacci);
updateTree();
tree.notifyAll();
}
}
}
private boolean isNumber(Object node) {
try {
Integer.parseInt(node.toString());
return true;
} catch (Exception e) {
return false;
}
}
public boolean isFinished(Object node) {
return node.toString().indexOf("finish") >= 0;
}
public int fibo(int n) {
if (n <= 0)
return 0;
else if (n == 1 || n == 2)
return n;
else
return fibo(n-1) + fibo(n-2);
}
Predicate<Node> tester = (node)->{
if (!isNumber(node))
return false;
Iterator<Node> itr = model.iterator(node);
itr.next();
while (itr.hasNext()) {
if (!isFinished(itr.next()))
return false;
}
return true;
};
void updateTree() {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
tree.updateUI();
}
});
}
} |
|
Но насколько я понимаю, смысла в этих потоках в данном случае нет, так как дерево блокируется одним потоком. Можно ли как-то реализовать многопоточную обработку дерева синхронизуя потоки по узлам, а не полностью по дереву?
Вроде можно как-то сделать с помощью ReentrantLock? Но я не пойму пока как это сделать. Помогите пожалуйста.
Вот класс узла:
| Java |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
| public abstract class Node implements Iterable<Node>, Comparable<Node>, Serializable {
protected Object data;
protected Node parent;
private final Lock lock = new ReentrantLock();
public Lock getLock() {
return lock;
}
public Node getParent() {
return parent;
}
public void add(Node son) throws Exception {
for (Node node : this) {
if (node.equals(son))
throw new Exception(son.toString() + " already exists!");
}
basicAdd(son);
}
public abstract void basicAdd(Node son);
public void remove() {
if (this.parent == null)
return;
Iterator<Node> it = parent.iterator();
while (it.hasNext()) {
Node node = it.next();
if (node == this) {
it.remove();
return;
}
}
}
public abstract Node createNode(Object data);
public int compareTo(Node o) {
Node obj = (Node)o;
return data.toString().compareTo(obj.data.toString());
}
public void setData(Object data) {
this.data = data;
}
public Object getData() {
return data;
}
public Object getChild(int index) {
int i = 0;
for (Node node : this) {
if (i == index)
return node;
i++;
}
return null;
}
public int getChildCount() {
int i = 0;
for (Node node : this)
i++;
return i;
}
public int getIndexOfChild(Node son) {
int i = 0;
for (Node node : this) {
if (node == son)
return i;
i++;
}
return -1;
}
public boolean isLeaf() {
return (getChildCount() == 0);
}
public String toString() {
return data.toString();
}
@Override
public abstract Iterator iterator();
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((data == null) ? 0 : data.hashCode());
result = prime * result + ((parent == null) ? 0 : parent.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Node other = (Node) obj;
if (data == null) {
if (other.data != null)
return false;
} else if (!data.equals(other.data))
return false;
if (parent == null) {
if (other.parent != null)
return false;
} else if (!parent.equals(other.parent))
return false;
return true;
}
public void forwardTraverse(Consumer<Node> p) {
p.accept(this);
for (Node node : this) {
node.forwardTraverse(p);
}
}
public void backwardTraverse(Consumer<Node> p) {
final Stack<Node> stack = new Stack<Node>();
this.forwardTraverse((node)->stack.push((Node)node));
while (!stack.empty())
p.accept(stack.pop());
}
public Node findNode(Predicate<Node> tester) {
Node result = null;
if (tester.test(this))
return this;
else
for (Node node : this) {
result = node.findNode(tester);
if (result != null)
return result;
}
return null;
}
} |
|
(
Сообщение от jeremen
