Android 多线程详解

1、Thread类常用方法（1）public static Thread currentThread()：返回当前调用的线程（2）public final String getName()：返回当前线程名称（3）public long getId()：返回当前线程标识id（4）public final void setName(String threadName)：设置线程名称（5）public void start()：执行一个新的线程（6）public final void stop()：关闭一个线程，不

2、推荐使用因为该方法可能会产生死锁，推荐使用在Thread中设置标识符结束运行的代码（7）public static void sleep(long time)：等待一段时间后在运行线程，单位是毫秒进程概念在同一时间内执行多个程序的操作系统都有进程的概念。一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间、一组系统资源。在进程的概念中，每一个进程的内部数据和状态都是完全独立的。在Windows操作系统下我们可以通过Ctrl+Alt+Del组合键查看进程，在UNIX和Linux操作系统下是通过PS命令查看进程的。打开Windows当前运行的进程，如图在Wind

3、ows操作系统中一个进程就是一个exe或dll程序，它们相互独立，互相也可以通信，在Android操作系统中进程间的通信应用也是很多Android空进程线程概念多线程指的是在单个程序中可以同时运行多个不同的线程，执行不同的任务。多线程意味着一个程序的多行语句可以看上去几乎在同一时间内同时运行。线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制。但与进程不同的是，同类的多个线程共享一块内存空间和一组系统资源，所以系统在各个线程之间切换时，资源占用要比进程小得多，正因如此，线程也被称为轻量级进程。一个进程中可以包含多个线程。如图所示是计时器程序进程和线程之间的关系，主线程负责管

4、理子线程，即子线程的启动、挂起、停止等操作Java中的线程Java的线程类是 java.lang.Thread类。当生成一个Thread类的对象之后，一个新的线程就产生了。Java中每个线程都是通过某个特定Thread对象的方法run()来完成其操作的，方法run( )称为线程体下面是构建线程类几种常用的方法：public Thread()public Thread(Runnable target)public Thread(Runnable target, String name)public Thread(String name)参数 target 是一个实现Runnable接口的实例，它

5、的作用是实现线程体的run()方法。目标target可为null，表示由本身实例来执行线程。name参数指定线程名字，但没有指定的构造方法，线程的名字是JVM分配的，例如JVM指定为thread-1、thread-2等名字Handler处理Runnable线程public class AppLoadingActivity extends BaseActivity         private Handler handler = new Handler();         private Runnabl

6、e updateThread = new Runnable()    Override  public void run()         线程运行的代码   Override protected void onCreate(Bundle savedInstanceState)    /向Handler中添加处理线程    handler.post(updateThread);private void checkLogin(

7、)    /删除Handler中的线程   handler.removeCallbacks(updateThread);1、Java中的实现线程体方式在Java中有两种方法实现线程体：一是继承线程类Thread，二是实现接口Runnable。下面我们先看看继承线程类Thread方式。（1）继承线程类Thread该方式继承线程类Thread并重写其中的方法 run()，在初始化这个类实例的时候，目标target可为null，表示由本实例来执行线程体。由于Java只支持单重继承，用这种方法定义的类不能再继承其他父类import 

8、java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader; public class T extends Thread    boolean isRunning = true;   int timer = 0;   /*    * 线程体代码

9、    */   Override   public void run()      while (isRunning)         try           Thread.currentThread().sleep(1000); &

10、#160;        timer+;          System.out.println("逝去了 " + timer + " 秒");         catch (InterruptedException e)  &#

11、160;        e.printStackTrace();                   public static void main(String args)      T t = new T();     t.start(

12、);     System.out.println("计时器启动.");     BufferedReader br = new BufferedReader(new InputStreamReader(System.in);     try         String line = br.readLine();  

13、      if (line.equalsIgnoreCase("1")           t.isRunning = false;              catch (IOException e)     

14、60;   e.printStackTrace();        在main主方法中通过new T()创建子线程，并通过 t.start()方法 启动子线程，main主方法所在线程为主线程，主线程负责管理其他的子线程。本例进程、主线程和子线程之间的关系如图。子线程启动之后就开始调用run()方法，run()是一个线程体，在子线程中处理事情就是在这里编写代码实现的。本案例中子线程要做的事情就是：休眠1s，计时器加1，再反复执行。Thread.currentThread().sleep(1000)就是休眠1s。为能够

15、停止线程，在主线程中增加了一个标识，通过在控制台输入一个字符“1”来改变该标识t1.isRunning = false，从而结束这个线程。注意：事实上线程中有一个stop()方法也可以停止线程，但是由于这种方法会产生线程死锁问题，所以在新版JDK中已经废止了，它的替代解决方法就是增加标识，就是我们在本例中采用的方案1.关于线程休眠问题对线程休眠问题，其实还是在用单线程的思维模式考虑问题，多数情况下PC都是单CPU，某个时间点只能有一个线程运行。所谓多线程就是多个线程交替执行就好像同时运行似的。因此，休眠当前线程可以交出CPU控制权，让其它的线程有机会运行，多个线程之间只有交替运行效率才是最高的

16、，这就像我们开车过十字路口，只有我等等，让你先过，你再等等让他先过，才能保证最高效率，否则就会造成交通系统崩溃，对线程情况也是一样的。因此，多线程中线程的休眠是程序运行的最有效方式2.关于线程体死循环问题在单线程中如果是死循环，程序应就会死掉，没有反应，但是多线程中线程体(run方法)中的死循环，可以保证线程一直运行，如果不循环线程，则运行一次就停止了。在上面的例子中线程体运行死循环，可以保证线程一直运行，每次运行都休眠1s，然后唤醒，再然后把时间信息输出到控制台。所以，线程体死循环是保证子线程一直运行的前提。由于是子线程它不会堵塞主线程，就不会感觉到程序死掉了。但是需要注意的是有时确实执行一

17、次线程体，就不需要循环了。程序运行后开始启动线程，线程启动后就计算逝去的时间，每过1s将结果输出到控制台。当输入1字符后线程停止，程序终止，如图（2）实现接口Runnable构造线程时有两个带有Runnable target参数的构造方法：Thread(Runnable target);Thread(Runnable target, String name)。其中的target就是线程目标对象了，它是一个实现Runnable的类，在构造Thread类时候把目标对象(实现Runnable的类)传递给这个线程实例，由该目标对象(实现Runnable的类)提供线程体run()方法。这时候实现接口Ru

18、nnable的类仍然可以继承其他父类import java.awt.BorderLayout;import java.awt.Button;import java.awt.Frame;import java.awt.Label;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;public class T2 extends Frame implements ActionListener

19、, Runnable    private Label label;   private Button button1;   private Thread clockThread;   private boolean isRunning = false;   private int timer = 0; &#

20、160; public T2()      button1 = new Button("结束计时");     label = new Label("计时器启动.");     button1.addActionListener(this);     setLayout(new 

21、BorderLayout();     add(button1, "North");     add(label, "Center");     setSize(320, 480);     setVisible(true);     clockThread = new Thread(this);&

22、#160;    /* 线程体是Clock对象本身，线程名字为"Clock" */     clockThread.start(); /* 启动线程 */     isRunning = true;      Override   public void actionPerfor

23、med(ActionEvent event)      isRunning = false;      Override   public void run()      while (isRunning)         try     

24、      Thread.currentThread().sleep(1000);          timer+;          label.setText("逝去了 " + timer + " 秒");   &#

25、160;     catch (InterruptedException e)           e.printStackTrace();                   public static void main(String args)  

26、60;   T2 a = new T2();   注：创建一个Thread成员变量clockThread，才用构造方法new Thread(this)创建一个线程对象，其中创建线程使用的构造方法Thread(Runnable target)，其中的this就是代表本实例，它是一个实现了Runnable接口的实现类类似于1>创建自定义类，实现Runable接口public class loginThread implements Runnable   Override  public voi

27、d run()    .  2>在用处运行线程new Thread(new loginThread().start(); （3）调用Thread中的匿名内部类在Android应用开发中经常使用该种方法import java.awt.BorderLayout;import java.awt.Button;import java.awt.Frame;import java.awt.Label;import java.awt.event.ActionEvent;import java.awt.e

28、vent.ActionListener;public class T3 extends Frame implements ActionListener    private Label label;   private Button button1;   private Thread clockThread;   private boolean&#

29、160;isRunning = false;   private int timer = 0;   public T3()      button1 = new Button("结束计时");     label = new Label("计时器启动.");  

30、;   button1.addActionListener(this);     setLayout(new BorderLayout();     add(button1, "North");     add(label, "Center");     setSize(320, 480);    

31、 setVisible(true);     / 线程体是Clock对象本身，线程名字为"Clock"     clockThread = new Thread(new Runnable()         Override        public voi

32、d run()           while (isRunning)              try                Thread.currentThread().slee

33、p(1000);               timer+;               label.setText("逝去了 " + timer + " 秒");   

34、           catch (InterruptedException e)                e.printStackTrace();                 &

35、#160;                  );     / 启动线程     clockThread.start();     isRunning = true;      Override  &

36、#160;public void actionPerformed(ActionEvent event)      isRunning = false;      public static void main(String args)      T3 a = new T3();    Android中的线程主线程（又叫

37、UI线程）的职责是显示UI控件、处理UI事件、启动子线程、停止子线程和更新UI，子线程的职责是计算逝去的时间和向主线程发出更新UI消息public class T extends Activity    /Handler将会相关操作加入到主线程的最后，进行UI修改的相关操作   private Handler handler = new Handler()      Override &

38、#160;   public void handleMessage(Message msg)         switch (msg.what)         case 0:          Toast.makeText(T.this, "123"

39、;, Toast.LENGTH_SHORT).show();          break;                super.handleMessage(msg);        ;   Override   publi

40、c void onCreate(Bundle savedInstanceState)      super.onCreate(savedInstanceState);     setContentView(R.layout.tab_host);     .          /可出现在其它位置处     new Thread(new

41、60;Runnable()         Override        public void run()           / 进行耗时操作的代码块          .       

42、;   /子线程传递数据给主线程          Message msg = new Message();          /obj保存传递的数据          msg.obj = "123"          /what传递的标志为int&

43、#160;         msg.what = 0;          handler.sendMessage(msg);             ).start();   AsyncTask实现异步任务public abstract class 

44、AsyncTask<Params, Progress, Result>：Params：“启动任务执行的输入参数”Progress：“后台任务执行的进度”Result：“后台计算结果的类型”一个异步任务的执行一般包括以下几个步骤：1.execute(Params. params)，执行一个异步任务，需要我们在代码中调用此方法，触发异步任务的执行。2.onPreExecute()，在execute(Params. params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记。3.doInBackground(Params. params)，在onPreE

45、xecute()完成后立即执行，用于执行较为费时的操作，此方法将接收输入参数和返回计算结果。在执行过程中可以调用publishProgress(Progress. values)来更新进度信息。4.onProgressUpdate(Progress. values)，在调用publishProgress(Progress. values)时，此方法被执行，直接将进度信息更新到UI组件上。5.onPostExecute(Result result)，当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，直接将结果显示到UI组件上。在使用的时候，有几点需要格外注意：（1）异步任务的

46、实例必须在UI线程中创建（2）execute(Params. params)方法必须在UI线程中调用（3）不要手动调用onPreExecute()，doInBackground(Params. params)，onProgressUpdate(Progress. values)，onPostExecute(Result result)这几个方法（4）不能在doInBackground(Params. params)中更改UI组件的信息（5）一个任务实例只能执行一次，如果执行第二次将会抛出异常（6）对于可能随时关闭，或等待时间非常长的的操作，要使用isCancelled()来判断是否操作被关闭,

47、可使用cancel(true)来关闭异步进程（7）每个 AsyncTask 只能被执行一次，多次调用将会引发异常public class MainActivity extends Activity   private MyTask mTask;    Override    public void onCreate(Bundle savedInstanceState)    

48、  mTask = new MyTask();      /调用execute之后，执行AsyncTask的相关方法    mTask.execute("");    /在后台未执行时，调用onCancelled（）方法    mTask.cancel(true);      private class MyTask extends

49、60;AsyncTask<String, Integer, String>          Override           protected void onPreExecute()              最先执行的代码，用于初始化            

50、      Override           protected String doInBackground(String. params)            第二执行代码部分，后台运行时间较长的代码部分（不能省去）                  Override  

51、         protected void onPostExecute(String result)            接收从doInBackground运行后返回的代码部分,执行完后台任务后更新UI,显示结果                  Override         

52、 protected void onCancelled()            取消执行中的任务时更改UI，在UI线程中使用cancle()来调用                    Override            protected void onProgressU

53、pdate(Integer. progresses)            用于更新进度条信息           isCancelled():用于判断后台进程是否关闭             例如代码：  public class MainActivity extends Activity   privat

54、e static final String TAG = "ASYNC_TASK"private Button execute;  private Button cancel;private ProgressBar progressBar;private TextView textView;private MyTask mTask;Overridepublic void onCreate(

55、Bundle savedInstanceState) super.onCreate(savedInstanceState);setContentView(R.layout.main);execute = (Button) findViewById(R.id.execute);execute.setOnClickListener(new View.OnClickListener() Overridepublic void onClick(View v) /注意每次需new一个实例,新建的

56、任务只能执行一次,否则会出现异常mTask = new MyTask();mTask.execute("");execute.setEnabled(false);cancel.setEnabled(true););cancel = (Button) findViewById(R.id.cancel);cancel.setOnClickListener(new View.OnClickListener() Overridepublic void onClick(View

57、0;v) /取消一个正在执行的任务,onCancelled方法将会被调用mTask.cancel(true););progressBar = (ProgressBar) findViewById(R.gress_bar);textView = (TextView) findViewById(R.id.text_view);private class MyTask extends AsyncTask<String, Integer, String&g

58、t; /onPreExecute方法用于在执行后台任务前做一些UI操作Overrideprotected void onPreExecute() Log.i(TAG, "onPreExecute() called");textView.setText("loading.");/doInBackground方法内部执行后台任务,不可在此方法内修改UI，传递的参数是从UI线程中execute的参数该方法中存放着执行时间长的运行Overrideprotected String do

59、InBackground(String. params) if(isCancelled()   return null;/ Tak被取消了s，环马上退出循Log.i(TAG, "doInBackground(Params. params) called");         try HttpClient client = new DefaultHttpClient();HttpGet get

60、60;= new HttpGet(params0);HttpResponse response = client.execute(get);if (response.getStatusLine().getStatusCode() = HttpStatus.SC_OK) HttpEntity entity = response.getEntity();InputStream is = entity.getContent();long to

61、tal = entity.getContentLength();ByteArrayOutputStream baos = new ByteArrayOutputStream();byte buf = new byte1024;int count = 0;int length = -1;while (length = is.read(buf) != -1) baos.write(

62、buf, 0, length);count += length;/调用publishProgress公布进度,最后onProgressUpdate方法将被执行publishProgress(int) (count / (float) total) * 100);/为了演示进度,休眠500毫秒Thread.sleep(500);return new String(baos.toByteArray(), "gb2312"); catch&#

63、160;(Exception e) Log.e(TAG, e.getMessage();return null;  /onProgressUpdate方法用于更新进度信息Override  protected void onProgressUpdate(Integer. progresses)   Log.i(TAG, "onProgressUpdate(Progress. progresses) called");

64、progressBar.setProgress(progresses0); textView.setText("loading." + progresses0 + "%");/onPostExecute方法用于在执行完后台任务后更新UI,显示结果/参数来自于doInBackground（）执行完成之后的返回值Overrideprotected void onPostExecute(String result) Log.i(TAG, "onPost

65、Execute(Result result) called"); textView.setText(result);execute.setEnabled(true);cancel.setEnabled(false);/onCancelled方法用于在取消执行中的任务时更改UI，在UI线程中使用cancle()来调用Overrideprotected void onCancelled() Log.i(TAG, "onCancelled() called");textView.setTex

66、t("cancelled");progressBar.setProgress(0);execute.setEnabled(true);cancel.setEnabled(false);多线程下载  1>MainActivity.java代码import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.

67、io.IOException;import java.io.InputStream;import java.io.RandomAccessFile;import .HttpURLConnection;import .MalformedURLException;import .ProtocolException;import .URL; import com.chenshun.util.SDCardInfo; import android.os.Bundle;import android

68、.os.Handler;import android.os.Message;import android.app.Activity;import android.text.TextUtils;import android.view.Menu;import android.view.View;import android.widget.EditText;import android.widget.ProgressBar;import android.widget.TextView;import androi

69、d.widget.Toast; public class MainActivity extends Activity          protected static final int DOWN_LOAD_ERROR = 0;         protected static 

70、;final int SERVER_ERROR = 1;         private static final int DOWNLOAD_ALL = 2;         private static final int UPDATE_TEXT = 3;&

71、#160;        private EditText et_path;         private ProgressBar pb;         private TextView tv_process;     

72、60;           private int currentProcess = 0;/当前进度                 public static int threadCount = 3;  &#

73、160;      public static int runningThread = 3;                 private Handler handler = new Handler()     

74、60;              Override                   public void handleMessage(Message msg)      &#

75、160;                      switch(msg.what)                        

76、0;    case DOWN_LOAD_ERROR:                                     Toast.makeText(MainActivit

77、y.this, "下载失败", Toast.LENGTH_SHORT).show();                                     break; 

78、60;                          case SERVER_ERROR:                   

79、0;                 Toast.makeText(MainActivity.this, "服务器请求失败！", Toast.LENGTH_SHORT).show();                 &

80、#160;                   break;                            case

81、60;DOWNLOAD_ALL:                                     Toast.makeText(MainActivity.this, "所有文件都已下载！",&

82、#160;Toast.LENGTH_SHORT).show();                                     break;      

83、0;                     case UPDATE_TEXT:                         

84、            tv_process.setText("当前进度：" + 100 * pb.getProgress()/pb.getMax() + "%");                  

85、;                   break;                              

86、;                          super.handleMessage(msg);                   

87、0;                    Override    protected void onCreate(Bundle savedInstanceState)         super.onCreate(savedInstanc

88、eState);        setContentView(R.layout.activity_main);               et_path = (EditText) findViewById(R.id.edit_path);        pb

89、 = (ProgressBar) findViewById(R.id.pb);        tv_process = (TextView) findViewById(R.id.tv_process);           public void downLoad(View view)   

90、;           final String path = et_path.getText().toString().trim();             Toast.makeText(MainActivity.this, "点击下载！path=" + path&

91、#160;+ "tSDCardPath = " + SDCardInfo.getSDPath(), Toast.LENGTH_SHORT).show();                         if(TextUtils.isEmpty(path) &

92、#160;                      Toast.makeText(MainActivity.this, "路径输入有错误！", Toast.LENGTH_SHORT).show();           

93、0;           return;                          /*           &

94、#160;  * 主线程中主要是用来修改UI因此将耗时长的操作放在子线程中              * 比如说：访问网络、修改UI（除对于精度条为特例）              */        

95、;     new Thread()                        public void run()             

96、60;                   try                              

97、                  /1:连接服务器，获取一个文件，获取文件长度，在本地创建一个和服务器打下一样的文件                         &

98、#160;                     URL url = new URL(path);                     

99、;                          System.out.println("path : " + path);            

100、0;                                  /创建URL连接              &#

101、160;                                HttpURLConnection conn = (HttpURLConnection) url.openConnection();   

102、                                            /设置连接时间5秒    

103、60;                                          conn.setConnectTimeout(5000);  

104、0;                                            /设置连接方式    注：此

105、处是大小写敏感                                               conn.setReq

106、uestMethod("GET");                                             &#

107、160; /获取返回码 200:请求成功                                             

108、  int code = conn.getResponseCode();                                        

109、;       System.out.println("返回码：" + code);                                  

110、;             if(200 = code )                                

111、;                         /f服务器返回文件的长度                       

112、;                                 int length= conn.getContentLength();         &

113、#160;                                              System.out.println(

114、"文件总长度：" + length);                                           

115、60;            /设置进度条最大值                                    

116、                    pb.setMax(length);                           

117、                                                  

118、                                  /在客户端本地创建出来一个大小跟服务器文件一样大小的零时文件           

119、                                             /RandomAccessFile.RandomAccess

120、File(String arg0, String arg1)                                          

121、60;             /arg0：文件存储名  arg1：文件存储访问方式                              

122、60;                         RandomAccessFile raf = new RandomAccessFile("/sdcard/setup.chm","rwd");      

123、                                                  

124、/指定文件长度                                                 

125、;       raf.setLength(length);                                       &

126、#160;                raf.close();                                                        /假设是3个线程      &#