Здравствуйте.
Есть вычурная задача, навеянная чтением доки:
1. класс, создающий большие нечётные числа (в примере ниже - это NumProducer) и расширяющий класс Observable для оповещения "всех страждущих";
2 два "страждущих" класса-наблюдателя, ждущих изменений от NumProducer'a:
2.1. NumFactor - его задача есть факторизация BigInteger числа, хранимого в объекте NumProducer (т.е. разложение на простые множители);
2.2. NumLogger - его задача есть запись в лог того BigInteger-числа, что только что создалось и сидит в объекте NumProducer.
NumProducer генерит числа в двух потоках (на моей машине они всегда имеют номера 10 и 11).
Задача в том, чтобы NumFactor и NumLogger занимались своей обработкой *не* в 10 и11 потоках, а в своих собственных.
Не могу понять, как это всё "свести воедино", поможыте плз.
Вот код (сильно прошу не пинать, учусь ибо):
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.
import java.util.*;
import java.math.*;
import java.text.*;
class NumHandling {
private static DateFormat df = new SimpleDateFormat("HH:mm:ss.SSS");
static class NumProducer extends Observable implements Runnable {
private final static int MAX_BITS = 48; // max count of bits in BigInt numbers
private static Random r = new Random();
private final BigInteger bi;
private final long creatorTid; // tid that creates object and sumbit it to be handled
private final Date creatorTime;
private NumProducer() {
bi = new BigInteger(MAX_BITS, r).or(BigInteger.ONE); // always *odd* number!
creatorTid = Thread.currentThread().getId();
creatorTime = new Date(); // cal.getTime();
}
static NumProducer getNew() { // fabrica
return new NumProducer();
}
public String toString() { return bi+" (creatorTid="+creatorTid+", creatorTime="+df.format(creatorTime)+")"; }
public int hashCode() { return bi.hashCode(); }
public boolean equals(Object o) { return o instanceof NumProducer && ((NumProducer)o).bi.equals(bi); }
public void run() {
long tid = Thread.currentThread().getId();
for(int i=0; i<3; i++) {
NumProducer p = NumProducer.getNew();
System.out.println( "NumProducer, tid="+tid+": create num="+p );
// make just created object `p` be visible to all involved observers:
setChanged(); // from Observable class
notifyObservers(p); // from Observable class
try {Thread.sleep(500 + r.nextInt(500) );} catch(Exception x){x.printStackTrace();}
}
}
}
static class NumFactor implements Runnable, Observer {
@Override
public void run() {
long tid = Thread.currentThread().getId();
System.out.println("NumFactor, run(), tid="+tid);
}
@Override
public void update(Observable arg0, Object arg1) {
System.out.println("NumFactor, tid="+Thread.currentThread().getId()+": have to factorize num="+arg1);
// todo: make factorization of generated number (arg1)
}
}
static class NumLogger implements Observer, Runnable {
@Override
public void run() {
long tid = Thread.currentThread().getId();
System.out.println("NumLogger, run(), tid="+tid);
// how ??? >>> update(Observable arg0, Object arg1)
}
@Override
public void update(Observable arg0, Object arg1) {
System.out.println("NumLogger, tid="+Thread.currentThread().getId()+": have to log num="+arg1);
// todo: make logging of generated number (arg1)
}
}
////////////////////////// m a i n //////////////////////////
public static void main(String[] aa) {
NumFactor o0 = new NumFactor();
NumLogger o1 = new NumLogger();
NumProducer p = new NumProducer();
Thread ts0 = new Thread(o0);
Thread ts1 = new Thread(o1);
ts0.start();
ts1.start();
p.addObserver(o0);
p.addObserver(o1);
Thread t0 = new Thread(p);
Thread t1 = new Thread(p);
t0.start();
t1.start();
}
} // class PrimesHandling
Output:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
NumFactor, run(), tid=8
NumLogger, run(), tid=9
NumProducer, tid=10: create num=26328559610221 (creatorTid=10, creatorTime=20:09:22.690)
NumProducer, tid=11: create num=190363836163951 (creatorTid=11, creatorTime=20:09:22.690)
NumLogger, tid=10 : have to log num=26328559610221 (creatorTid=10, creatorTime=20:09:22.690)
NumLogger, tid=11 : have to log num=190363836163951 (creatorTid=11, creatorTime=20:09:22.690)
NumFactor, tid=10 : have to factorize num=26328559610221 (creatorTid=10, creatorTime=20:09:22.690)
NumFactor, tid=11 : have to factorize num=190363836163951 (creatorTid=11, creatorTime=20:09:22.690)
NumProducer, tid=11: create num=47378974542453 (creatorTid=11, creatorTime=20:09:23.330)
NumLogger, tid=11: have to log num=47378974542453 (creatorTid=11, creatorTime=20:09:23.330)
NumFactor, tid=11: have to factorize num=47378974542453 (creatorTid=11, creatorTime=20:09:23.330)
NumProducer, tid=10: create num=48260041978835 (creatorTid=10, creatorTime=20:09:23.690)
NumLogger, tid=10: have to log num=48260041978835 (creatorTid=10, creatorTime=20:09:23.690)
NumFactor, tid=10: have to factorize num=48260041978835 (creatorTid=10, creatorTime=20:09:23.690)
NumProducer, tid=11: create num=207469418360109 (creatorTid=11, creatorTime=20:09:23.830)
NumLogger, tid=11: have to log num=207469418360109 (creatorTid=11, creatorTime=20:09:23.830)
NumFactor, tid=11: have to factorize num=207469418360109 (creatorTid=11, creatorTime=20:09:23.830)
NumProducer, tid=10: create num=260987830801937 (creatorTid=10, creatorTime=20:09:24.362)
NumLogger, tid=10: have to log num=260987830801937 (creatorTid=10, creatorTime=20:09:24.362)
NumFactor, tid=10: have to factorize num=260987830801937 (creatorTid=10, creatorTime=20:09:24.362)
Как сделать, чтобы для NumLogger'a вместо tid=10/11 было tid=9, и аналогично для NumFactor'a чтобы было tid=8 ?
