SWT对话框自动关闭

 SWI程序在运行的过程中，通常会出现处理某一事件的时候，需要等待一段时间，处理结束以后，主界面再响应其他的事件。在这种情况下，一般会通过显示一个提示对话框，说明该操作正在运行，请稍候，处理结束后，关闭对话框，主界面可用。
如果仅仅是弹出一个对话框，此时主程序会等待对话框的结束，然后执行对话框后面的代码，需要对话框自己适当时自己关闭，可以考虑采用多线程的方式。
我们在对话框代码中，
（1）继承了Dialog类并实现了Runnable接口；
（2）打开对话框，然后启动时间处理线程；
（3）当处理线程执行run()完毕后，关闭对话框。

在我的工程中，点击按钮以后，发送消息给客户端，客户端进行处理，间隔一段时间，
向服务端返回处理结果，在这个过程中，服务端主界面进行等待，弹出对话框（里面线程对于socket端口进行read处理），当read到内容以后，线程关闭对话框，主线程继续进行。

1. package gui;
3. import java.io.DataInputStream;
4. import java.io.IOException;
5. import org.eclipse.swt.SWT;
6. import org.eclipse.swt.events.ShellAdapter;
7. import org.eclipse.swt.events.ShellEvent;
8. import org.eclipse.swt.widgets.Dialog;
9. import org.eclipse.swt.widgets.Display;
10. import org.eclipse.swt.widgets.Label;
11. import org.eclipse.swt.widgets.Shell;
13. /**
14.  * ShowProcessDialog implements the Runnable to read the check echo result in
15.  * other thread.
16.  */
17. public class ShowProcessDialog extends Dialog implements Runnable {
19.     /**
20.      * reads the socket to get the echo result
21.      */
22.     private Thread tRead;
24.     protected Object result;
26.     protected Shell shell;
28.     protected Display display = getParent().getDisplay();
30.     private DataInputStream dataIn;
32.     private String echoStr;
33.     
34.     /**
35.      * Create the dialog
36.      * 
37.      * @param parent
38.      * @param style
39.      */
40.     public ShowProcessDialog(Shell parent, int style) {
41.         super(parent, style);
42.     }
44.     /**
45.      * Create the dialog
46.      * 
47.      * @param parent
48.      */
49.     public ShowProcessDialog(Shell parent, DataInputStream in) {
50.         this(parent, SWT.NONE);
51.         dataIn = in;
52.     }
54.     /**
55.      * Open the dialog
56.      * 
57.      * @return the result
58.      */
59.     public Object open() {
60.         createContents();
61.         //start the thread to read the Agent echo result
62.         tRead = new Thread(this);
63.         tRead.start();
64.         shell.open();
65.         shell.layout();
66.         while (!shell.isDisposed()) {
67.             if (!display.readAndDispatch())
68.                 display.sleep();
69.         }
70.         return result;
71.     }
73.     /**
74.      * Create contents of the dialog
75.      */
76.     protected void createContents() {
77.         shell = new Shell(getParent(), SWT.TITLE | SWT.BORDER | SWT.APPLICATION_MODAL);
78.         shell.setSize(345, 181);
79.         shell.setText("运行提示");
80.         final Label label = new Label(shell, SWT.NONE);
81.         label.setAlignment(SWT.CENTER);
82.         label.setText("正在执行监测，请稍候...");
83.         label.setBounds(55, 70, 204, 44);
84.     }
86.     /**
87.      * closes the dialog, because read Thread do this, it's
88.      * other thread, so should close dialog through dialog
89.      * thread using syncExec.
90.      */
91.     public void close() {
92.         display.getDefault().syncExec(new Runnable() {
93.             public void run() {
94.                 shell.close();
95.                 shell.dispose();
96.             }
97.         });
98.     }
100.     public void run() {
101.         try {
102.             System.out.println("wait for reading...");
103.             echoStr = dataIn.readUTF();
104.         } catch (IOException e) {
105.             System.out.println("read from Agent exception.");
106.         }
107.         close();
108.     }
109.     
110.     public String getEcho() {
111.         return echoStr;
112.     }
113. }