Thread的两种实现方法

转载 2016年05月31日 09:07:59

一:

Android中有两种实现线程thread的方法:

一种是,扩展Java.lang.Thread类 
另一种是,实现Runnable接口

 

二:
Thread类代表线程类,它的两个最主要的方法是: 
run()——包含线程运行时所执行的代码 
Start()——用于启动线程

 

三: 

Handler 机制,它是Runnable和Activity交互的桥梁,在run方法中发送Message,在Handler里,通过不同的Message执行不同的任务。

(Handler的设计实际上是为了应用程序内其他线程和主线程进行通信,因为只有主线程才能更新UI,其他线程不行)

下面分别给出两种线程的实现方法,其一,扩展java.lang.Thread类,也就是把run()方法写到线程里面:

[c-sharp] view plain copy
  1. package com.my;  
  2. import android.app.Activity;  
  3. import android.os.Bundle;  
  4. import android.os.Handler;  
  5. import android.os.Message;  
  6. import android.util.Log;  
  7. import android.view.View;  
  8. import android.view.View.OnClickListener;  
  9. import android.widget.Button;  
  10. public class Demo_For_Copy extends Activity  
  11. {  
  12.     public Button button;  
  13.       
  14.     public Handler mHandler=new Handler()  
  15.     {  
  16.         public void handleMessage(Message msg)  
  17.         {  
  18.             switch(msg.what)  
  19.             {  
  20.             case 1:  
  21.                 button.setText(R.string.text2);  
  22.                 break;  
  23.             default:  
  24.                 break;        
  25.             }  
  26.             super.handleMessage(msg);  
  27.         }  
  28.     };  
  29.       
  30.     /** Called when the activity is first created. */  
  31.     @Override  
  32.     public void onCreate(Bundle savedInstanceState)  
  33.     {  
  34.         super.onCreate(savedInstanceState);  
  35.         setContentView(R.layout.main);  
  36.         button=(Button)findViewById(R.id.button);  
  37.   
  38.         Thread thread=new Thread(new Runnable()  
  39.         {  
  40.             @Override  
  41.             public void run()  
  42.             {  
  43.                 Log.e("1111""111111111");  
  44.                 // TODO Auto-generated method stub  
  45.                 Message message=new Message();  
  46.                 message.what=1;  
  47.                 mHandler.sendMessage(message);  
  48.             }  
  49.         });  
  50.         thread.start();  
  51.     }  
  52. }  

 

 

其二,实现Runnable接口,让类实现Runnable接口,然后把run方法单独提出来:

[c-sharp] view plain copy
  1. package com.my;  
  2. import android.app.Activity;  
  3. import android.os.Bundle;  
  4. import android.os.Handler;  
  5. import android.os.Message;  
  6. import android.util.Log;  
  7. import android.view.View;  
  8. import android.view.View.OnClickListener;  
  9. import android.widget.Button;  
  10. import android.widget.LinearLayout;  
  11. public class Title_Change_Demo extends Activity implements Runnable  
  12. {  
  13.     public Button button;  
  14.     public LinearLayout my_layout;  
  15.       
  16.     public Handler mHandler=new Handler()  
  17.     {  
  18.         public void handleMessage(Message msg)  
  19.         {  
  20.             switch(msg.what)  
  21.             {  
  22.             case 1:  
  23.                 button.setText(R.string.text2);  
  24.                 break;  
  25.             default:  
  26.                 break;            
  27.             }  
  28.             my_layout.invalidate();  
  29.             super.handleMessage(msg);  
  30.         }  
  31.     };  
  32.       
  33.     /** Called when the activity is first created. */  
  34.     @Override  
  35.     public void onCreate(Bundle savedInstanceState)  
  36.     {  
  37.         super.onCreate(savedInstanceState);  
  38.         setContentView(R.layout.main);  
  39.           
  40.         button=(Button)findViewById(R.id.button);  
  41.         my_layout=(LinearLayout)findViewById(R.id.my_layout);  
  42.           
  43.         Thread thread=new Thread(this);  
  44.         thread.start();  
  45.     }  
  46.       
  47.     @Override  
  48.     public void run()  
  49.     {  
  50.         Log.e("ok""111111111");  
  51.         // TODO Auto-generated method stub  
  52.         Message message=new Message();  
  53.         message.what=1;  
  54.         mHandler.sendMessage(message);  
  55.     }  

Thread 两种实现方式的区别

一、类继承方式实现线程package thread.ticket; class Ticket1 extends Thread{ public Ticket1(String name) ...
  • limuzi13
  • limuzi13
  • 2015年09月27日 23:15
  • 990

多线程实现的两种方式及其区别

继承Threadpublic class Demo2_Thread { public static void main(String[] args) { MyThread mt ...
  • StriverLi
  • StriverLi
  • 2017年02月26日 21:07
  • 1667

创建线程的两种方式及原理

创建线程的第一种方式: 1.  定义类继承Thread类。 2.  重写run()。 3.  创建线程对象。 4.  调用start()启动线程。 class Thread {     ...
  • fandoudou123
  • fandoudou123
  • 2015年08月20日 11:51
  • 567

黑马程序员--Java多线程的两种实现方式:继承Thread类 & 实现Runable接口

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 创建和启动线程的两种传统方式: Java提供了线程类Thread来创建多线程的程序...
  • master_c
  • master_c
  • 2015年10月20日 08:40
  • 726

Java 继承Thread类和实现Runnable接口的区别

ava中线程的创建有两种方式: 1.  通过继承Thread类,重写Thread的run()方法,将线程运行的逻辑放在其中 2.  通过实现Runnable接口,实例化Thread类     在...
  • xiangzhihong8
  • xiangzhihong8
  • 2016年06月13日 23:28
  • 1948

Thread与Runnable两种多线程方式

多线程是Java一大特点,如果没有多个处理器,在逻辑上还是单核处理器在执行,如果在语言层面给予支持多核处理器可以在微观上同时的执行程序,Intel处理器支持超线程技术,例如双核四线程的i3甚至是8核1...
  • micro_hz
  • micro_hz
  • 2015年09月04日 18:21
  • 888

匿名内部类创建线程的两种方式

我们知道多线程的实现有两种方式,一种是继承Thread类,另一种是实现Runnable接口,然后再重写run方法,我们在普通的创建线程中,显然是比较麻烦的,那么有没有一个算是简单的方法呢?今天小钱就给...
  • qian_ch
  • qian_ch
  • 2017年02月26日 17:32
  • 3840

线程有两种实现方法的具体区别

Java中有两种实现多线程的方式。一是直接继承Thread类,二是实现Runnable接口。那么这两种实现多线程的方式在应用上有什么区别呢?  第一种方式:使用Runnable接口创建线程 第...
  • chajinglong
  • chajinglong
  • 2015年08月24日 13:44
  • 7511

实现多线程的两种方法:继承Thread类或实现Runnable接口

实现多线程的两种方法:继承Thread类或实现Runnable接口Java中实现多线程有两种方法:继承Thread类和实现Runnable接口,在程序开发中只要是多线程,我们一般都是实现Runnabl...
  • u010412719
  • u010412719
  • 2015年07月22日 21:27
  • 1594

java实现线程的两种方法有什么区别?

如果一个类通过继承Thread来实现多线程的话,则不适合多个线程共享资源,而通过实现Runnable就可以做到这一点,下面给lz举个例子: Java code class MyTheard ext...
  • u010572068
  • u010572068
  • 2013年07月03日 21:52
  • 1352
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Thread的两种实现方法
举报原因:
原因补充:

(最多只允许输入30个字)