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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.CharArrayWriter;
import java.io.PrintWriter;
import java.lang.Thread.UncaughtExceptionHandler;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JProgressBar;
import javax.swing.JTextArea;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;
class ReportPrinterTask implements Runnable {
public void run() {
String threadName = Thread.currentThread().getName();
Thread.currentThread().setName(threadName + " [print]");
try
{
// ...
JasperPrint printfile = JasperFillManager.fillReport(reportfile, parametres,connect);
// ...
}
finally
{
Thread.currentThread().setName(threadName);
}
}
}
class GenericThreadFactory implements ThreadFactory {
private static final Map<String, AtomicInteger> staticCounters = new HashMap<String, AtomicInteger>();
public AtomicInteger getStaticCounter(String base) {
AtomicInteger staticCounter = null;
synchronized (staticCounters)
{
staticCounter = staticCounters.get(base);
if (staticCounter == null) {
staticCounter = new AtomicInteger(1);
staticCounters.put(base, staticCounter);
}
}
return staticCounter;
}
private final AtomicInteger counter = new AtomicInteger(1);
private final boolean daemon;
private final ThreadGroup threadGroup;
public GenericThreadFactory() {
this("threadpool");
}
public GenericThreadFactory(String base) {
this(base, false);
}
public GenericThreadFactory(String base, boolean isDaemon) {
threadGroup = new ThreadGroup(base + "-" + getStaticCounter(base).getAndIncrement());
daemon = isDaemon;
}
@Override
public Thread newThread(Runnable r)
{
Thread newThread = new Thread(threadGroup, r, threadGroup.getName() + "-" + counter.getAndIncrement());
newThread.setDaemon(daemon);
newThread.setPriority(Thread.NORM_PRIORITY);
return newThread;
}
}
class ReportManager {
ExecutorService threadPool = Executors.newCachedThreadPool(new GenericThreadFactory("ReportManager"));
public void print() throws ExecutionException, TimeoutException {
Future<?> future = threadPool.submit(new ReportPrinterTask());
try
{
future.get(120, TimeUnit.SECONDS);
}
catch (InterruptedException e)
{
throw new RuntimeException("Wait of printing task has been interrupted", e);
}
}
}
class ReportGui implements UncaughtExceptionHandler {
ExecutorService threadPool = Executors.newCachedThreadPool(new GenericThreadFactory("ReportGuiAction"));
ReportManager manager = new ReportManager();
public void invokeOnThreadPool(Runnable task) {
try
{
Future<?> future = threadPool.submit(task);
future.get();
}
catch (InterruptedException e)
{
throw new RuntimeException(e);
}
catch (ExecutionException e)
{
e.printStackTrace();
}
}
public void invokeOnEdt(Runnable task) {
try
{
SwingUtilities.invokeAndWait(task);
}
catch (InterruptedException e)
{
throw new RuntimeException(e);
}
catch (InvocationTargetException e)
{
e.printStackTrace();
}
}
@Override
public void uncaughtException(Thread t, Throwable e)
{
CharArrayWriter writer = new CharArrayWriter();
PrintWriter printWriter = new PrintWriter(writer);
e.printStackTrace(printWriter);
JTextArea text = new JTextArea(writer.toString(), 0, 120);
JOptionPane.showMessageDialog(null, text, "Error", JOptionPane.ERROR_MESSAGE);
}
public void displayMain() {
final JFrame frame = new JFrame("Report");
frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
final JButton button = new JButton("print");
button.addActionListener(new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
JProgressBar progressBar = null;
try
{
button.setEnabled(false);
progressBar = new JProgressBar();
progressBar.setIndeterminate(true);
progressBar.setString("Printing in progress ...");
progressBar.setStringPainted(true);
frame.getContentPane().add(progressBar, BorderLayout.SOUTH);
launchPrint();
}
finally
{
button.setEnabled(true);
frame.getContentPane().remove(progressBar);
}
}
});
frame.getContentPane().add(button, BorderLayout.CENTER);
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
public void launchPrint() {
invokeOnThreadPool(new Runnable()
{
@Override
public void run()
{
try
{
manager.print();
}
catch (ExecutionException e)
{
uncaughtException(Thread.currentThread(), e);
}
catch (TimeoutException e)
{
uncaughtException(Thread.currentThread(), e);
}
}
});
}
} |
