SWT高级控件之SWT线程

《Eclipse SWT/JFACE 核心应用》 清华大学出版社 11 SWT线程

11.1 创建线程

1. 继承Thread
创建一个类，并继承自Thread类，覆盖run()方法。
package www.swt.com.ch11;

public class ExtendThread extends Thread {
int count = 0;
public void run() {
   while (count <10) {
    System.out.println("Extend Thread");
    count++;
   }
}
}
其中run()方法体中的程序是线程执行的程序。调用如下：
   //创建线程对象
   ExtendThread extendThread = new ExtendThread ();
   //启动线程后开始调用线程对象中的run()方法体
   extendThread.start(); 

2. 实现Runnable接口
当某个类必须继承另外一个类时，不能继承Thread类，可以通过实现Runnable接口实现线程的特性。
public class Parent {
}
public class Child extends Parent implements Runnable{
int count = 0;
public void run() {
   while (count <10) {
    System.out.println("Implements Thread");
    count++;
   }
}
}
调用方式：
   //创建Child对象，Child类实现了Runnable接口
   Child child = new Child();
   //创建线程对象，将child对象作为构造参数
   Thread implementThread = new Thread ( child );
   implementThread.start();

11.2 SWT中的UI线程

    SWT中Display对象就是一个UI线程，并且负责管理队列中的事件。
// 窗口未释放时
   while (!shell.isDisposed()) {
    // 如果display对象事件队列中没有了等待的事件，就让该线程进入等待状态
    if (!display.readAndDispatch ())
     display.sleep ();
   }
   display.dispose ();
    当某一个队列中的事件是一个非常耗时的事件时，比如检索文件或查询大量数据的数据库时，需要为长时间处理的程序单独开辟出一个线程来执行。

11.3 其他线程访问UI线程

 

   //创建一个线程，该线程每0.1秒更新一次滚动条的值
   Runnable runnable = new Runnable() {
    public void run() {
     //线程运行的主体
     for (int i = minimus; i < maximum; i++) {
      try {
       //让线程睡眠0.1秒
       Thread.sleep(100);
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
     //如果使用以下以行代码更新滚动条的值，运行时会出现Invalid thread access
      //progressBar.setSelection(progressBar.getSelection() + 1);
      //让UI线程更新滚动条的值
      display.asyncExec(new Runnable() {
       //这也是一个线程，该线程的功能是更新滚动条的值，一瞬间就结束了
       public void run() {
        if (progressBar.isDisposed())
         return;
        progressBar.setSelection(progressBar.getSelection() + 1);
       }
      });
     }
    }
   };
   //启动这个线程
   new Thread(runnable).start();
    若要访问UI界面上的对象必须通过UI线程来访问，就是说在非UI线程中调用UI对象是不允许的，这是出于线程安全的考虑。

    Display对象中负责调用其他线程的方法有以下3种：
◆ asyncExec(Runnable runnable)：异步启动新的线程。
◆ syncExec(Runnable runnable)：同步启动新的线程。UI线程会等待runnable对象执行结束后才会继续进行。getSyncThread()方法可以获得线程对象。
◆ timerExec(int milliseconds, Runnable runnable)：指定一段时间再启动新的线程。用此方法创建的线程，将会在指定的时间后再启动线程。与UI线程是异步的。

Display对象中，与UI线程相关的方法如下：
◆ 获得当前的UI线程对象：getThread()
◆ 使UI线程处于休眠状态：sleep()
◆ 唤醒UI线程：wake()

11.4 改进的进度条

 

package www.swt.com.ch11;

import org.eclipse.swt.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;

public class ProgressBarComplex {
// 表示线程的状态
static boolean bCancel = false;
public static void main(String[] args) {
   Display display = new Display();
   final Shell shell = new Shell(display);
   shell.setText("ProgressBar");
   shell.setLayout(new GridLayout(2, false));
   // 开始和取消按钮
   final Button start = new Button(shell, SWT.NONE);
   start.setText("开始");
   Button cancel = new Button(shell, SWT.NONE);
   cancel.setText("取消");
   // 创建滚动条实例
   final ProgressBar progressBar = new ProgressBar(shell, SWT.HORIZONTAL);
   GridData data = new GridData();
   data.horizontalSpan = 2;
   data.grabExcessHorizontalSpace = true;
   progressBar.setLayoutData(data);
   progressBar.setMaximum(100);// 设置最大值
   progressBar.setMinimum(0);// 设置最小值
   final int maximum = progressBar.getMaximum();// 获取最大值
   final int minimus = progressBar.getMinimum();// 获取最小值
   // 为开始按钮注册事件
   start.addSelectionListener(new SelectionAdapter() {
    // 当单击开始按钮时
    public void widgetSelected(SelectionEvent e) {
     // 首先设置开始按钮不可用状态
     start.setEnabled(false);
     bCancel = false;
     // 创建更新进度条的线程
     Runnable runnable = new Runnable() {
      public void run() {
       for (int i = minimus; i < maximum; i++) {
        try {
         Thread.sleep(100);
        } catch (InterruptedException e) {
        }
        if (bCancel) {
         break;
        }
        // 注意在更新进度条时加上了判断线程状态的条件
        shell.getDisplay().asyncExec(new Runnable() {
         public void run() {
          if (progressBar.isDisposed())
           return;
          progressBar.setSelection(progressBar.getSelection() + 1);
          // 如果此时取消了线程，将进度条设置为初始状态
          if (bCancel) {
           progressBar.setSelection(0);
          }
         }
        });
        // 如果此时取消了线程，结束该循环，这个线程也就结束了
        // 并重置线程状态
        if (bCancel) {
//         bCancel = false;
         break;
        }
       }
      }
     };
     // 启动这个线程
     new Thread(runnable).start();
    }
   });
   // 注册取消按钮事件
   cancel.addSelectionListener(new SelectionAdapter() {
    // 当单击取消按钮时
    public void widgetSelected(SelectionEvent e) {
     // 如果此时线程在执行，则取消线程并将开始按钮置为可用
     if (!bCancel) {
      bCancel = true;
      start.setEnabled(true);
     }
    }
   });
   shell.pack();
   shell.open();
   while (!shell.isDisposed()) {
    if (!display.readAndDispatch())
     display.sleep();
   }
   bCancel = true;
   display.dispose();
}
}
显示效果：

书中的逻辑有点问题：
1. sleep后没有判断是否满足退出条件，会导致如下异常：
Exception in thread "Thread-0" org.eclipse.swt.SWTException: Widget is disposed
at org.eclipse.swt.SWT.error(Unknown Source)
at org.eclipse.swt.SWT.error(Unknown Source)
at org.eclipse.swt.SWT.error(Unknown Source)
at org.eclipse.swt.widgets.Widget.error(Unknown Source)
at org.eclipse.swt.widgets.Widget.getDisplay(Unknown Source)
at www.swt.com.ch11.ProgressBarComplex$1$1.run(ProgressBarComplex.java:50)
at java.lang.Thread.run(Unknown Source)
原因是在sleep时程序已经退出，再访问UI时导致异常。
2. 在UI线程更新完后，有下面的代码：
        // 如果此时取消了线程，结束该循环，这个线程也就结束了
        // 并重置线程状态
        if (bCancel) {
//         bCancel = false;
         break;
        }
bCancel=false; 未注释掉，设置为false，而此时UI更新线程正在处理，在下面代码时：
          if (bCancel) {
           progressBar.setSelection(0);
          }
判断bCancel为false，因此没有设置progressBar的位置为0，因为bCancel标志的设置而导致多个线程协调混乱。
◆ 代码中改善的部分以红色字体显示。

11.5 多线程程序设计

（1）MutiTaskTestDrive类为系统的入口：
package www.swt.com.ch11;

import org.eclipse.swt.widgets.Display;

import www.swt.com.util.ImageFactory;

public class MutiTaskTestDrive {
public static void main(String[] args) {
   Display display = Display.getDefault();
   MutiTaskGUI mutiTask= new MutiTaskGUI();
   mutiTask.getShell().open();
   while (!mutiTask.getShell().isDisposed()) {
    if (!display.readAndDispatch()) {
     display.sleep();
    }
   }
   ImageFactory.dispose();
   display.dispose();
}
}
（2）MutiTaskGUI类为主窗口类：
package www.swt.com.ch11;

import org.eclipse.swt.SWT;

public class MutiTaskGUI {
private Shell shell = null;
private Table table = null;
public MutiTaskGUI( ){
   //构造方法中调用初始化窗口的方法
   init();
}
//初始化窗口方法
public void init() {
   shell = new Shell();
   shell.setLayout(new GridLayout());
   shell.setText("多线程");
   Button bt = new Button ( shell , SWT.NONE);
   bt.setText("开始一个任务");
   // 创建表格对象
   table = new Table(shell, SWT.BORDER);
   table.setLayoutData( new GridData(SWT.FILL,SWT.FILL,true,true));
   table.setHeaderVisible(true);
   table.setLinesVisible(true);
   String[] header = new String[]{"任务","进度","操作"};
   // 创建表头
   for (int i = 0; i < 3; i++) {
    TableColumn col = new TableColumn(table, SWT.NONE);
    col.setText( header[i] );
   }
   //设置表头宽度
   table.getColumn(0).setWidth(80);
   table.getColumn(1).setWidth(150);
   table.getColumn(2).setWidth(80);
   shell.pack();
   //注册创建任务按钮事件
   bt.addSelectionListener( new SelectionAdapter(){
    //当单击创建一个任务按钮时
    public void widgetSelected(SelectionEvent e) {
     //首先创建一个Task对象
     Task task = new Task ( table );
     //然后再表格中添加一行
     task.createTableItem();
     //最后启动该任务，该任务为一个线程
     task.start();
    }
   });
}
//获得和设置属性的getter和setter方法
public Shell getShell() {
   return shell;
}
public void setShell(Shell shell) {
   this.shell = shell;
}
public Table getTable() {
   return table;
}
public void setTable(Table table) {
   this.table = table;
}
}
（3）Task类为线程类：
package www.swt.com.ch11;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TableEditor;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.ProgressBar;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;

import www.swt.com.util.ImageFactory;

//该Task类继承自Thread，并且覆盖了run()方法
public class Task extends Thread {
//该类的一些属性
private Table table = null;
//是否停止的标志
private boolean done = false;
//声明进度条对象
private ProgressBar bar = null;
private int min = 0;
private int max = 100;
public Task(Table table) {
   this.table = table;
}
//创建表格中的一行
public void createTableItem() {
   TableItem item = new TableItem(table, SWT.NONE);
   item.setText(this.getName());
   item.setImage(ImageFactory.loadImage(table.getDisplay(), ImageFactory.PROGRESS_TASK));
   // 创建一个进度条
   bar = new ProgressBar(table, SWT.NONE);
   bar.setMinimum(min);
   bar.setMaximum(max);
   // 创建一个可编辑的表格对象
   TableEditor editor = new TableEditor(table);
   editor.grabHorizontal = true;
   editor.grabVertical = true;
   // 将进度条绑定到第二列中
   editor.setEditor(bar, item, 1);
   //重新创建一个可编辑的表格对象
   editor = new TableEditor(table);
   editor.grabHorizontal = true;
   editor.grabVertical = true;
   //创建一个按钮
   Button stop = new Button(table, SWT.NONE);
   stop.setText("Stop");
   editor.setEditor(stop, item, 2);
   stop.addSelectionListener(new SelectionAdapter() {
    //当停止按钮按下时，设置停止标记true
    public void widgetSelected(SelectionEvent e) {
     if (!isDone())
      setDone(true);
    }
   });
}
//线程方法体，与前面单个的进度条的程序类似
public void run() {
   for (int i = min; i < max; i++) {
    try {
     Thread.sleep(100);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    table.getDisplay().asyncExec(new Runnable() {
     public void run() {
      if (bar.isDisposed())
       return;
      bar.setSelection(bar.getSelection() + 1);
     }
    });
    //如果停止，则结束该线程
    if (isDone()) {
     break;
    }
   }
}
//获得和设置属性的getter和setter方法
public Table getTable() {
   return table;
}
public void setTable(Table table) {
   this.table = table;
}
public boolean isDone() {
   return done;
}
public void setDone(boolean done) {
   this.done = done;
}
}

运行效果：


    上面的代码里同样存在多线程协调的问题，当没有stop，而直接关闭程序退出时，Task线程刷新界面时会出现异常。