Android 多线程编程

摘要：Android的应用程序支持多线程，多线程编程为我们充分利用系统资源提供了便利，同时也为设计复杂UI和耗时操作提供了途径，提升了安卓用户的使用体验。

Android的应用程序支持多线程，多线程编程为我们充分利用系统资源提供了便利，同时也为设计复杂UI和耗时操作提供了途径，提升了安卓用户的使用体验。Android的多线程和JAVA没有多大变化，唯一的变化大概在于无法直接使用CANVAS修改屏幕元素，当然安卓为我们提供了surfaceview类来实现多线程中通过画布canvas修改屏幕。这为设计UI和开发游戏带来了方便。因此，研究和使用多线程编程，对我们深入学习安卓编程有着十分重要的作用。

线程的方法比较多，常用的有：

start()；

run()；

sleep()；

stop()；

destroy()；

join();

suspend()；

resume()；

yield()；

wait()；

notify()；

线程启动一定要使用start方法,线程操作使用run方法，线程休眠使用sleep方法，线程停止使用stop,线程销毁使用destroy方法,线程同步使用JOIN方法，前面三种最常用，一般来说这三种就可以满足大部分线程使用需求，run结束时线程自动死亡，stop,destroy虽然也能停止线程，但不推荐使用，,前者会产生异常，后者是强制终止，不会释放锁，一般会在RUN里设置一个状态信号来等其自动结束，这里使用volatile boolean bThreadRun。后面是暂停，继续，挂起，由于会产生死锁问题，很少使用。大部分情况会使用wait和notify替代；

这里我使用一个线程来计算变量并更新窗口标题。主要代码如下：使用eclipse创建一个项目。为Activity添加onStart，onPause, onStop等方法，Activity是我们最常使用的一个类，也是android的核心类，为应用程序管理并显示一个屏幕，开发的人不应该对其陌生。Activity活动主要的方法有，onCreate，onStart，onStop，onPause，onResume， onRestart，onDestroy，onRestoreInstanceState，onSaveInstanceState，一般的执行顺序是，onCreate，onStart，onResume，当窗口不是最顶层时，执行onPause，onstop,为顶层时，执行onRestart，onResume，一直循环，直到onDestroy.如果保存窗口，重载onSaveInstanceState，并在进入时重载onRestoreInstanceState。这里我在Activity的方法onStart里创建线程：

01.MyThread myThread = new MyThread();

02. myThread.start();

在下面添加MyThread的实现代码：

01.public class MyThread extends Thread {

02. // 声明字符串变量

03. public MyThread() {

04. }

05.

06. @Override

07. public void start() {

08. super.start();

09. }

10.

11. // 线程的主要工作方法

12. @Override

13. public void run() {

14. while (true) {

15. try {

16. sleep(5000);

17. if (c > ((1 << 31) - 1)) {

18. c = 0;

19. } else {

20. c++;

21. }

22. Message message = new Message();

23. message.what = 1;

24. mHandler.sendMessage(message);

25. } catch (InterruptedException ex) {

26. }

27. }

28. }

29.

30. }

实现updatetitle方法：

01.public void updateTitle() {

02. setTitle("test thread " + c);

03. }

这里没有使用updatetitle直接更新窗口，而是使用handler,这是因为直接使用是不安全的，会造成线程重启等问题。Android 引进了Handler 这个特殊的类，用它作为Runnable和Activity交互的桥梁，所以我们只能在run方法中发送Message,而在Handler里，通过不同的Message执行不同的任务。为程序添加handler；

01.private Handler mHandler = new Handler() {

02. public void handleMessage(Message msg) {

03. switch (msg.what) {

04. case 1:

05. updateTitle();

06. break;

07. }

08. };

09. };

最后完整的代码如下，使用线程处理数据，并把数据显示在窗口上：

01.package com.test;

02.

03.import android.app.Activity;

04.import android.os.Bundle;

05.import java.lang.Thread;

06.import android.os.Message;

07.import android.os.Handler;

08.import android.graphics.Color;

09.

10.public class TestThreadActivity extends Activity {

11. int c = Color.BLUE;

12. MyThread myThread;

13. volatile boolean bThreadRun = false;

14.

15. /** Called when the activity is first created. */

16. @Override

17. public void onCreate(Bundle savedInstanceState) {

18. super.onCreate(savedInstanceState);

19. setContentView(R.layout.main);

20. }

21.

22. @Override

23. protected void onRestoreInstanceState(android.os.Bundle savedInstanceState) {

24. super.onRestoreInstanceState(savedInstanceState);

25. }

26.

27. @Override

28. protected void onSaveInstanceState(android.os.Bundle outState) {

29. super.onSaveInstanceState(outState);

30. }

31.

32. @Override

33. protected void onStart() {

34. super.onStart();

35. myThread = new MyThread();

36. myThread.start();

37. bThreadRun = true;

38. }

39.

40. @Override

41. protected void onRestart() {

42. super.onRestart();

43. }

44.

45. @Override

46. protected void onResume() {

47. super.onResume();

48. }

49.

50. @Override

51. protected void onPause() {

52. super.onPause();

53. bThreadRun = false;

54. // myThread.stop();

55. }

56.

57. @Override

58. protected void onStop() {

59. super.onStop();

60. onPause();

61. }

62.

63. @Override

64. protected void onDestroy() {

65. super.onDestroy();

66. // myThread.destroy();

67. }

68.

69. private Handler mHandler = new Handler() {

70. public void handleMessage(Message msg) {

71. switch (msg.what) {

72. case 1:

73. updateTitle();

74. break;

75. }

76. };

77. };

78.

79. public void updateTitle() {

80. setTitle("test thread " + c);

81. setTitleColor(c);

82. }

83.

84. public class MyThread extends Thread {

85. // 声明字符串变量

86. public MyThread() {

87. }

88.

89. @Override

90. public void start() {

91. super.start();

92. }

93.

94. // 线程的主要工作方法

95. @Override

96. public void run() {

97. while (bThreadRun) {

98. try {

99. sleep(100);

100. if (c > ((1 << 16) - 1)) {

101. c = 0;

102. } else {

103. c += 100;

104. }

105. Message message = new Message();

106. message.what = 1;

107. mHandler.sendMessage(message);

108. } catch (InterruptedException ex) {

109. }

110. }

111. }

112.

113. }

114.

115.}

线程还有另外一种常用的方法是编写Runnable接口，这里对代码做一些修改，使用线程实现对主窗口重绘，全部代码如下：

01.package com.test;

02.

03.import android.app.Activity;

04.import android.content.Context;

05.import android.os.Bundle;

06.import java.lang.Thread;

07.import android.view.View;

08.import android.graphics.Canvas;

09.import android.graphics.Color;

10.import android.graphics.Paint;

11.import android.graphics.Paint.Style;

12.import android.graphics.Rect;

13.

14.public class TestThreadActivity extends Activity {

15. int c = Color.BLUE;

16. MyThread myThread;

17. volatile boolean bThreadRun = false;

18. MyView mv;

19.

20. /** Called when the activity is first created. */

21. @Override

22. public void onCreate(Bundle savedInstanceState) {

23. super.onCreate(savedInstanceState);

24. // setContentView(R.layout.main);

25. mv = new MyView(this);

26. setContentView(mv);

27. }

28.

29. public class MyView extends View {

30. MyView(Context context) {

31. super(context);

32. }

33.

34. @Override

35. protected void onDraw(Canvas canvas) {

36. // TODO Auto-generated method stub

37. super.onDraw(canvas);

38.

39. // 首先定义一个paint

40. Paint paint = new Paint();

41.

42. // 绘制矩形区域-实心矩形

43. // 设置颜色

44. paint.setColor(c);

45. // 设置样式-填充

46. paint.setStyle(Style.FILL);

47. // 绘制一个矩形

48. canvas.drawRect(new Rect(0, 0, getWidth(), getHeight()), paint);

49. }

50.

51. }

52.

53. @Override

54. protected void onRestoreInstanceState(android.os.Bundle savedInstanceState) {

55. super.onRestoreInstanceState(savedInstanceState);

56. }

57.

58. @Override

59. protected void onSaveInstanceState(android.os.Bundle outState) {

60. super.onSaveInstanceState(outState);

61. }

62.

63. @Override

64. protected void onStart() {

65. super.onStart();

66. //myThread = new MyThread();

67. //myThread.start();

68. new Thread (new MyThread()).start();

69. bThreadRun = true;

70. }

71.

72. @Override

73. protected void onRestart() {

74. super.onRestart();

75. }

76.

77. @Override

78. protected void onResume() {

79. super.onResume();

80. }

81.

82. @Override

83. protected void onPause() {

84. super.onPause();

85. bThreadRun = false;

86. // myThread.stop();

87. }

88.

89. @Override

90. protected void onStop() {

91. super.onStop();

92. onPause();

93. }

94.

95. @Override

96. protected void onDestroy() {

97. super.onDestroy();

98. // myThread.destroy();

99. }

100.

101. public class MyThread implements Runnable{

102. // 线程的主要工作方法

103. @Override

104. public void run() {

105. while (bThreadRun) {

106. try {

107. Thread.sleep(500);

108. if (c > ((1 << 31) – 1)) {

109. c = 0;

110. } else {

111. c += 100;

112. }

113. mv.postInvalidate();

114. } catch(InterruptedException e){

115. }

116. }

117. }

118.

119. }

120.

121.}