理解UI线程——SWT, Android, 和Swing的UI机理

2019独角兽企业重金招聘Python工程师标准>>>

在做GUI的时候, 无论是SWT, AWT, Swing 还是Android, 都需要面对UI线程的问题, UI线程往往会被单独的提出来单独对待, 试着问自己,

当GUI启动的时候, 后台会运行几个线程? 比如

1. SWT 从Main函数启动

2. Swing 从Main函数启动

3. Android 界面启动

常常我们被告知, 主线程, UI线程, 因此这里很多会回答, 有两个线程, 一个线程是Main, 另外一个是UI. 如果答案是这样, 这篇文章就是写给你的。

OK, 我们以SWT为例, 设计以下方案寻找答案, 第一步, 我们看能否找到两个线程:

1. 从Main中启动SWT的界面, 在启动界面前, 将Main所在的线程打印出来这里设计为Shell中嵌入一个Button

2. 点击Button, 运行一个耗时很长的操作, 反复修改Button的文字, 在该线程中打印该线程的名称

代码是这样的:

[java] view plain copy

public static void main(String[] args) {
final Display display = Display.getDefault();
final Shell shell = new Shell();
shell.setSize(500, 375);
shell.setText("SWT Application");
shell.setLayout(new FillLayout());
btn = new Button(shell, SWT.NULL);
btn.setText("shit");
registerAction();
shell.open();
shell.layout();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
shell.dispose();
display.dispose();
}
private static void registerAction() {
btn.addMouseListener(new MouseListener() {
@Override
public void mouseDoubleClick(MouseEvent e) {
// TODO Auto-generated method stub
}
@Override
public void mouseDown(MouseEvent e) {
methodA();
}
@Override
public void mouseUp(MouseEvent e) {
}
});
}
/**
* 持续的跑动, 打印线程的名称, 注意拖拽不动, 界面死掉, 直到跑完
*/
private static void methodA() {
for (int i = 0; i < count; i++) {
haveArest(300);
System.out.println("MethodA:" + Thread.currentThread().getName());
btn.setText(i + "");
}
}

haveArest方法在最后出现, 只是封装了一个让线程等待一段时间, 打印的结果都为main, 于是得到第一个重要的结论:

UI所在的线程和Main所在的线程都是同一个线程。

再来推断一把:

UI在哪个线程启动的, 则这个线程就是UI线程.

[java] view plain copy

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Thread t = new Thread(new Runnable() {
@Override
public void run() {
createUI();
}
});
t.start();
}
private static void createUI()
{
System.out.println(Thread.currentThread().getName());
final Display display = Display.getDefault();
final Shell shell = new Shell();
shell.setSize(500, 375);
shell.setText("SWT Application");
shell.setLayout(new FillLayout());
Button btn = new Button(shell, SWT.NULL);
btn.setText("shit");
shell.open();
shell.layout();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
shell.dispose();
display.dispose();
}

通过打印结果发现, 推论是正确的.

根据铺天盖地参考书提示, 有这样一条定律:

只可以存在一个UI线程

验证一下, 我们的验证方式是创建两个UI线程:

[java] view plain copy

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Thread t = new Thread(new Runnable() {
@Override
public void run() {
createUI();
}
});
t.start();
t = new Thread(new Runnable() {
@Override
public void run() {
createUI();
}
});
t.start();
}
private static void createUI()
{
System.out.println(Thread.currentThread().getName());
final Display display = new Display();
final Shell shell = new Shell();
shell.setSize(500, 375);
shell.setText("SWT Application");
shell.setLayout(new FillLayout());
Button btn = new Button(shell, SWT.NULL);
btn.setText("shit");
shell.open();
shell.layout();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
shell.dispose();
display.dispose();
}

但这里确实创建了两个线程。看来一个进程是可以创建两个线程的。

可以存在一个或者多个UI线程, 下次看到参考书这么写的时候, 可以BS它了。

之前犯了一个错误就是用Diplay display = Display.getDefault(); 这样得到的是前一个线程创建的Display，故不能创建. 造成只能创建一个UI线程的错觉

当然我们的研究不能到此为止, 我们需要探究一下, 为什么总是被告知更新UI的动作要放在UI线程中?

回到第一个例子中, 即:

[java] view plain copy

public static void main(String[] args) {
final Display display = Display.getDefault();
final Shell shell = new Shell();
shell.setSize(500, 375);
shell.setText("SWT Application");
shell.setLayout(new FillLayout());
btn = new Button(shell, SWT.NULL);
btn.setText("shit");
registerAction();
shell.open();
shell.layout();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
shell.dispose();
display.dispose();
}
private static void registerAction() {
btn.addMouseListener(new MouseListener() {
@Override
public void mouseDoubleClick(MouseEvent e) {
// TODO Auto-generated method stub
}
@Override
public void mouseDown(MouseEvent e) {
methodA();
}
@Override
public void mouseUp(MouseEvent e) {
}
});
}
/**
* 持续的跑动, 打印线程的名称, 注意拖拽不动, 界面死掉, 直到跑完
*/
private static void methodA() {
for (int i = 0; i < count; i++) {
haveArest(300);
System.out.println("MethodA:" + Thread.currentThread().getName());
btn.setText(i + "");
}
}

运行的时候拖动试试, 发现不动, 直到for循环中修改btn的操作完成.

这里我们不难明白一个观点:

同一个线程的情况下, 一个操作(拖动), 是需要等待另外一个操作(更新btn)完成后, 才可以进行的。

不难理解, 我们常用的做法是:

通过启动另外一个线程, 在cpu微小的间隔时间内，完成两个动作的交替

于是有了下面的代码:

[java] view plaincopy

private static Button btn;
private static final int count = 20;
public static void main(String[] args) {
final Display display = Display.getDefault();
final Shell shell = new Shell();
shell.setSize(500, 375);
shell.setText("SWT Application");
shell.setLayout(new FillLayout());
btn = new Button(shell, SWT.NULL);
btn.setText("shit");
registerAction();
shell.open();
shell.layout();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
shell.dispose();
display.dispose();
}
private static void registerAction() {
btn.addMouseListener(new MouseListener() {
@Override
public void mouseDoubleClick(MouseEvent e) {
// TODO Auto-generated method stub
}
@Override
public void mouseDown(MouseEvent e) {
methodB();
}
@Override
public void mouseUp(MouseEvent e) {
}
});
}
/**
* 为了解决拖拽不动, 界面死掉, 增加线程控制, 但产生了Invalid thread access的问题
*/
private static void methodB() {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < count; i++) {
haveArest(300);
System.out.println("MethodB:"
+ Thread.currentThread().getName());
btn.setText(i + "");
}
}
});
t.start();
}

但这样发现会报错, 原因是, 线程访问出错了, 因为有一个这样的规则需要我们保障:

所有的UI相关的操作, 务必保证在UI线程中更新.

为什么会有这样一条铁律? 原因是界面的消息需要分发到各大控件上面去, 如果不能保证UI在相同的线程, 分发起来就会比较复杂. UI本身占用的资源比较多. 如果在将UI分属不同的线程, 切换起来, 将耗费大量的CPU资源.

为了保证这条, SWT 是这么做的, 利用Diplay这个变量获取UI线程, 然后在其中做UI访问和操作:

[java] view plain copy

private static Button btn;
private static final int count = 20;
public static void main(String[] args) {
final Display display = Display.getDefault();
final Shell shell = new Shell();
shell.setSize(500, 375);
shell.setText("SWT Application");
shell.setLayout(new FillLayout());
btn = new Button(shell, SWT.NULL);
btn.setText("shit");
registerAction();
shell.open();
shell.layout();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
shell.dispose();
display.dispose();
}
private static void registerAction() {
btn.addMouseListener(new MouseListener() {
@Override
public void mouseDoubleClick(MouseEvent e) {
// TODO Auto-generated method stub
}
@Override
public void mouseDown(MouseEvent e) {
methodC();
}
@Override
public void mouseUp(MouseEvent e) {
}
});
}
private static void methodC() {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < count; i++) {
System.out.println("MethodB Thread:"
+ Thread.currentThread().getName());
haveArest(300);
final Display display = Display.getDefault();
final String s = i + "";
if ((display != null) && (!display.isDisposed())) {
display.asyncExec(new Runnable() {
@Override
public void run() {
System.out.println("MethodB Thread asyncExec:"
+ Thread.currentThread().getName());
btn.setText(s);
}
});
}
}
}
});
t.start();
}
private static void haveArest(int sleepTime)
{
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

后面会继续关注Swing和Android的例子, 相信这些也是大同小异的. 关键是, UI特殊, 但特殊性不在于它是一个额外的线程.

这样的应用其实很多, 比如我们不断刷表格的时候, 为了让界面能接受其它的响应事件, 一般都把刷表格的动作放置到另外的线程中, 用Display.asychronize()来保障其访问UI元素的安全行(即在UI中访问).

总结一下, 本文由如下结论:
UI线程和主线程,普通线程的关系
1. UI线程和Main线程没有必然联系, 从Main函数启动, 也可以从一个其它的线程启动. 启动UI的线程, 则为UI线程
2. 如果第一个线程启动了UI. 则第一个线程则成为UI线程. 如果第二个线程涉及UI操作, 则需要保证这个操作放在UI线程中. 否则会出现Invalid thread access错误.

SWT为什么会有Display.asyncExec(new Runnable())操作:
1. 当界面执行了长时段的UI操作, 比如进度条, 此时如果把更新UI的操作放在唯一的UI线程中执行, 那么本线程将全部消耗CPU资源, 造成界面无法拖动.拖动则界面死掉MethodA()。
2. 为了解决问题1, 我们一般另外启动一个线程进行操作, 这样使得界面可以拖动, 但是UI的操作无法在其它的线程中完成, 只能在UI线程中完成,
3. Display.asyncExec(new Runnable()的目的就是将这个动作放在UI线程中完成. 这样避免报错Invalid thread access

补充SWT的知识, 很多不明白Display.asyncExec 和Display.syncExec的区别, 用个例子说明一下:

[java] view plain copy

/**
* 在UI线程中跑动, 注意, 在UI线程中跑动asyncExec/syncExec都不能解决拖动的问题, 只能另起线程
* 才能解决如:methodC
*/
private static void methodD() {
for (int i = 0; i < count; i++) {
haveArest(300);
final Display display = Display.getDefault();
final String s = i + "";
if ((display != null) && (!display.isDisposed())) {
display.syncExec(new Runnable() {
@Override
public void run() {
//如果是asyncExec的话, 这里到最后次才执行
// asyncExec要等到发起asyncExec的线程执行完毕, 他才有机会执行。在单线程的情况下, 发起asyncExec的线程和asyncExec里面的run内容都在同一个线程
//所以要等到asyncExec执行完毕, asyncExec中run的东西, 才有机会执行
//syncExec则不同, 它务必要保证里面的方法执行后,再回到发起syncExec方法所在的线程, 所以这里相当于一个流畅的串行操作
btn.setText(s);
System.out.println("" + s);
}
});
}
}
}