Android UI线程分析

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

线程

在做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的文字, 在该线程中打印该线程的名称

代码是这样的:

1.public

static

void main(String[] args) {

2.final Display display = Display.getDefault();

3.final Shell shell = new Shell();

4. shell.setSize(500, 375);

5. shell.setText("SWT Application");

6. shell.setLayout(new FillLayout());

7. btn = new Button(shell, SWT.NULL);

8. btn.setText("shit");

9. registerAction();

10. shell.open();

11. https://www.360docs.net/doc/5f9091548.html,yout();

12.while (!shell.isDisposed()) {

13.if (!display.readAndDispatch())

14. display.sleep();

15. }

16. shell.dispose();

17. display.dispose();

18.}

19.private

static

void registerAction() {

20. btn.addMouseListener(new MouseListener() {

21. @Override

22.public

void mouseDoubleClick(MouseEvent e) {

23. // TODO Auto-generated method stub

24. }

25. @Override

26.public

void mouseDown(MouseEvent e) {

27. methodA();

28. }

29. @Override

30.public

void mouseUp(MouseEvent e) {

31. }

32. });

33.}

34./**

35.* 持续的跑动, 打印线程的名称, 注意拖拽不动, 界面死掉, 直到跑完

36.*/

37.private

static

void methodA() {

38.for (int i = 0; i < count; i++) {

39. haveArest(300);

40. System.out.println("MethodA:" +

Thread.currentThread().getName());

41. btn.setText(i + "");

42. }

43.}

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

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

再来推断一把:

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

1./**

2.* @param args

3.*/

4.public

static

void main(String[] args) {

5. // TODO Auto-generated method stub

6.

7. Thread t = new Thread(new Runnable() {

8. @Override

9.public

void run() {

10. createUI();

11. }

12. });

13. t.start();

14.}

15.

16.private

static

void createUI()

17.{

18. System.out.println(Thread.currentThread().getName());

19.final Display display = Display.getDefault();

20.final Shell shell = new Shell();

21. shell.setSize(500, 375);

22. shell.setText("SWT Application");

23. shell.setLayout(new FillLayout());

24. Button btn = new Button(shell, SWT.NULL);

25. btn.setText("shit");

26. shell.open();

27. https://www.360docs.net/doc/5f9091548.html,yout();

28.while (!shell.isDisposed()) {

29.if (!display.readAndDispatch())

30. display.sleep();

31. }

32. shell.dispose();

33. display.dispose();

34.}

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

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

只可以存在一个UI线程

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

1./**

2.* @param args

3.*/

4.public

static

void main(String[] args) {

5. // TODO Auto-generated method stub

6.

7. Thread t = new Thread(new Runnable() {

8. @Override

9.public

void run() {

10. createUI();

11. }

12. });

13. t.start();

14.

15. t = new Thread(new Runnable() {

16. @Override

17.public

void run() {

18. createUI();

19. }

20. });

21. t.start();

22.

23.

24.}

25.

26.private

static

void createUI()

27.{

28. System.out.println(Thread.currentThread().getName());

29.final Display display = new Display();

30.final Shell shell = new Shell();

31. shell.setSize(500, 375);

32. shell.setText("SWT Application");

33. shell.setLayout(new FillLayout());

34. Button btn = new Button(shell, SWT.NULL);

35. btn.setText("shit");

36. shell.open();

37. https://www.360docs.net/doc/5f9091548.html,yout();

38.while (!shell.isDisposed()) {

39.if (!display.readAndDispatch())

40. display.sleep();

41. }

42. shell.dispose();

43. display.dispose();

44.}

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

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

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

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

回到第一个例子中, 即:

1.public

static

void main(String[] args) {

2.final Display display = Display.getDefault();

3.final Shell shell = new Shell();

4. shell.setSize(500, 375);

5. shell.setText("SWT Application");

6. shell.setLayout(new FillLayout());

7. btn = new Button(shell, SWT.NULL);

8. btn.setText("shit");

9. registerAction();

10. shell.open();

11. https://www.360docs.net/doc/5f9091548.html,yout();

12.while (!shell.isDisposed()) {

13.if (!display.readAndDispatch())

14. display.sleep();

15. }

16. shell.dispose();

17. display.dispose();

18.}

19.private

static

void registerAction() {

20. btn.addMouseListener(new MouseListener() {

21. @Override

22.public

void mouseDoubleClick(MouseEvent e) {

23. // TODO Auto-generated method stub

24. }

25. @Override

26.public

void mouseDown(MouseEvent e) {

27. methodA();

28. }

29. @Override

30.public

void mouseUp(MouseEvent e) {

31. }

32. });

33.}

34./**

35.* 持续的跑动, 打印线程的名称, 注意拖拽不动, 界面死掉, 直到跑完

36.*/

37.private

static

void methodA() {

38.for (int i = 0; i < count; i++) {

39. haveArest(300);

40. System.out.println("MethodA:" +

Thread.currentThread().getName());

41. btn.setText(i + "");

42. }

43.}

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

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

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

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

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

于是有了下面的代码:

1.private

static Button btn;

2.

3.private

static

final

int count = 20;

4.public

static

void main(String[] args) {

5. final Display display = Display.getDefault();

6. final Shell shell = new Shell();

7. shell.setSize(500, 375);

8. shell.setText("SWT Application");

9. shell.setLayout(new FillLayout());

10. btn = new Button(shell, SWT.NULL);

11. btn.setText("shit");

12. registerAction();

13. shell.open();

14. https://www.360docs.net/doc/5f9091548.html,yout();

15. while (!shell.isDisposed()) {

16. if (!display.readAndDispatch())

17. display.sleep();

18. }

19. shell.dispose();

20. display.dispose();

21.}

22.private

static

void registerAction() {

23. btn.addMouseListener(new MouseListener() {

24. @Override

25. public

void mouseDoubleClick(MouseEvent e) {

26. // TODO Auto-generated method stub

27. }

28. @Override

29. public

void mouseDown(MouseEvent e) {

30. methodB();

31. }

32. @Override

33. public

void mouseUp(MouseEvent e) {

34. }

35. });

36.}

37./**

38.* 为了解决拖拽不动, 界面死掉, 增加线程控制, 但产生了Invalid thread

access的问题

39.*/

40.private

static

void methodB() {

41. Thread t = new Thread(new Runnable() {

42. @Override

43. public

void run() {

44. for (int i = 0; i < count; i++) {

45. haveArest(300);

46. System.out.println("MethodB:"

47. + Thread.currentThread().getName());

48. btn.setText(i + "");

49. }

50. }

51. });

52. t.start();

53.}

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

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

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

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

1.private

static Button btn;

2.

3.private

static

final

int count = 20;

4.public

static

void main(String[] args) {

5.final Display display = Display.getDefault();

6.final Shell shell = new Shell();

7. shell.setSize(500, 375);

8. shell.setText("SWT Application");

9. shell.setLayout(new FillLayout());

10. btn = new Button(shell, SWT.NULL);

11. btn.setText("shit");

12. registerAction();

13. shell.open();

14. https://www.360docs.net/doc/5f9091548.html,yout();

15.while (!shell.isDisposed()) {

16.if (!display.readAndDispatch())

17. display.sleep();

18. }

19. shell.dispose();

20. display.dispose();

21.}

22.private

static

void registerAction() {

23. btn.addMouseListener(new MouseListener() {

24. @Override

25.public

void mouseDoubleClick(MouseEvent e) {

26. // TODO Auto-generated method stub

27. }

28. @Override

29.public

void mouseDown(MouseEvent e) {

30. methodC();

31. }

32. @Override

33.public

void mouseUp(MouseEvent e) {

34. }

35. });

36.}

37.

38.private

static

void methodC() {

39. Thread t = new Thread(new Runnable() {

40. @Override

41.public

void run() {

42.for (int i = 0; i < count; i++) {

43. System.out.println("MethodB Thread:"

44. + Thread.currentThread().getName());

45.

46. haveArest(300);

47.final Display display = Display.getDefault();

48.final String s = i + "";

49.if ((display != null) && (!display.isDisposed())) {

50. display.asyncExec(new Runnable() {

51. @Override

52.public

void run() {

53. System.out.println("MethodB Thread

asyncExec:"

54. +

Thread.currentThread().getName());

55. btn.setText(s);

56. }

57. });

58. }

59. }

60. }

61. });

62. t.start();

63.}

64.

65.private

static

void haveArest(int sleepTime)

66.{

67.try {

68. Thread.sleep(sleepTime);

69. } catch (InterruptedException e) {

70. // TODO Auto-generated catch block

71. e.printStackTrace();

72. }

73.}

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

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

总结一下, 本文由如下结论:

UI线程和主线程,普通线程的关系

1. UI线程和Main线程没有必然联系, 从Main函数启动, 也可以从一个其它的线程启动. 启动UI的线程, 则为UI线程

2. 不允许出现两个UI线程. 如果第一个线程启动了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的区别, 用个例子说明一下:

1./**

2.* 在UI线程中跑动, 注意, 在UI线程中跑动asyncExec/syncExec都不能解决

拖动的问题, 只能另起线程

3.* 才能解决如:methodC

4.*/

5.private

static

void methodD() {

6.for (int i = 0; i < count; i++) {

7. haveArest(300);

8.final Display display = Display.getDefault();

9.final String s = i + "";

10.if ((display != null) && (!display.isDisposed())) {

11. display.syncExec(new Runnable() {

12. @Override

13.public

void run() {

14. //如果是asyncExec的话, 这里到最后次才执行

15. // asyncExec要等到发起asyncExec的线程执行完毕,

他才有机会执行。在单线程的情况下, 发起asyncExec的线程和asyncExec里面的run内容都在同一个线程

16. //所以要等到asyncExec执行完毕, asyncExec中run

的东西, 才有机会执行

17. //syncExec则不同, 它务必要保证里面的方法执行后,再

回到发起syncExec方法所在的线程, 所以这里相当于一个流畅的串行操作

18. btn.setText(s);

19. System.out.println("" + s);

20. }

21. });

22. }

23. }

24.}

按注释运行下, 就会发现这里面大有玄机, 不过我这边并不是为了解决SWT的问题, 而是针对所有的UI线程来的, 所以, 不再做解释.

推荐阅读. 该牛人的长篇大作.

多谢同事章导对SWT修正的问题. 即使弥补了误导大家的观点,

Android 也是相同的原理:

1. 通过多线程避免界面假死

2. 通过Hander保证访问界面元素在UI线程中进行.

其它的一些细微差别, 不需要多讲. 原理乃一个模子出来的.

一个Android Helloworld运行起来的时候, 有四个线程

1. 传说中的Main线程

2. 另外三个都是Binder Thread, 貌似是为了跨进程通信用的监听线程.

貌似很多Android的教程都把UI线程当特殊的一个线程.

辅助阅读；

SWT组件Diaplay提供syncExec与asyncExec方法，其原型为：syncExec (Runnable runnable)，asyncExec (Runnable runnable)，Runnable的run方法中可以封装要执行的代码，一般而言是UI相关的代码，如更新组件显示、刷新状态等。Diaplay是和线程关联的，其所在的线程一般称谓UI线程，可以有多个UI线程，每个UI线程一个Diaplay。所有的SWT组件相关代码，必须在UI线程之中执行。

syncExec与asyncExec相同点，都是为了让Runnable封装的代码在指定的Diaplay(比如某个产成Image的diaplay) 相关的UI线程中执行。如：imgCreateDiaplay.asyncExec(runnable)。需要说明的是，当前线程一般是非UI线程，也可以是UI线程(如其它UI相关线程如awt UI 线程，和为提高执行效率，多个SWT UI线程之间协作并发执行，甚至调用线程和执行runnable 的UI线程是同一个线程)

syncExec与asyncExec不相同点体现在对方法调用线程本身的影响，syncExec阻塞当前线

程直到UI线程完成runnable中的代码执行；而asyncExec则直接返回，不等待runnable中代码被执行，但并不是说asyncExec执行的代码一定不在同一个线程中，有些时候是同一个线程，只不过将代码的执行根据需要分成两个部分或多个部分处理。

两者的异同决定了其分别适应不同的场合，一般syncExec适合在需要同步UI更新之后继续执行的代码，asyncExec适合在不便、不能syuncExec的情况下使用。

syncExec适用情况比较简单，以下总结asyncExec的适用情况。

1、非UI线程需要调用在UI线程中调用的组件方法。非UI线程是相对与UI线程来讲的，UI线程准确的讲是diaplay变量所在的线程，因此非UI线程其实是非display所在的线程，其可以是任何其它线程，如UI无关的后台作业处理线程、SWT-AWT共用应用中的awt所在线程、其它display线程(这种情况比较少，一般应用于服务程序，如大量生成图片的多UI 线程，相互之间协调时的调用，如几个UI线程负责地图图片的绘制，然后交给另外一个UI 线程做装饰处理)；

2、跳出当前UI事件处理，安排后续事件。当前display所在的UI线程，在事件处理过程中，需要在执行完毕之后启动另外一个UI处理过程，可以使用asyncExec，发起另外一个UI线程处理，结束当前的UI处理。有几种情况下需要这么做：A、当前事件处理必须执行完毕，使应用到达一定的状态之后，做另外的UI处理，但是由于SWT、JFace或其它应用框架的存在，当前事件处理完成之后需要应用框架执行一些其它代码之后才可以执行另外的UI处理，否则会导致状态不一致，界面出错。但是当前事件处理完毕之后，不会出现其它事件来触发需要另外执行的代码，此时可以使用asyncExec，在框架的事件处理序列中插入另外一个事件，在当前事件处理完毕之后的某个时刻(一般很快)来执行；B、定时刷新或其它不是很重要的UI操作，通过asyncExec执行，不影响重要的UI事件处理。asyncExec所在的事件队列优先级较低。

3、事件比较密集，而且不均衡，有时非常密集，有时不太密集，为了将事件处理均衡处理，使UI线程始终能够应付自如，而不是延迟重要事件的处理、使用户感到界面迟钝现象，将不重要的事件放到低优先级序列中，从而保证用户响应性，界面整体的有效性。

asyncExec使用时需要注意的问题主要在于两个方面。

1、响应及时性。可以认为SWT存在两个事件队列，正常UI事件队列，需异步处理的队列，该队列优先级较低，asyncExec对应于SWT低优先级队列，因此有可能在正常队列事件较多、事件处理较慢的时候，asyncExec相关代码不能及时执行的问题，从而导致响应不够及时；

2、多线程同步问题。假如某段事件处理代码发出多个asyncExec请求，每个asyncExec

代码访问同一个变量，假设该变量是整数，第一次发出请求是值为1、第二次为2、第三次为3，所有请求发出，该事件处理完毕时，整数值为5，随后第一次发出的asyncExec请求执行，访问整数变量，此时为5，而本应该是1，其它几个有类似问题。

当然了，Display也提供了timerExec，可以将其理解为Timer和asyncExec两者的结合，代码在指定时间之后异步执行。

本文来自CSDN博客，转载请标明出处：

https://www.360docs.net/doc/5f9091548.html,/chulaixi/archive/2008/10/18/3095376.aspx