Handlernew thread runnablee和Thread之间的区别和联系 应用

来源：蜘蛛抓取(WebSpider) 时间：2016-05-13 08:36 标签： java thread runnable
Android中Handler、Thread(HanlderThread)、Runnable之间的关系
Android中Handler、Thread(HanlderThread)、Runnable之间的关系
发布: | 作者: | 来源:
| 查看:69次 | 用户关注：
　　在多线程编程这块，我们经常要使用Handler，Thread和Runnable这三个类，那么他们之间的关系你是否弄清楚了呢?　　首先说明Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。　　而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。　　HandlerT
　　在多线程编程这块，我们经常要使用Handler，Thread和Runnable这三个类，那么他们之间的关系你是否弄清楚了呢?　　首先说明的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。　　而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。　　HandlerThread顾名思义就是可以处理消息循环的线程，他是一个拥有Looper的线程，可以处理消息循环。　　与其说Handler和一个线程绑定，不如说Handler是和Looper一一对应的。　　最后需要说明的是，在UI线程(主线程)中：　　mHandler=new Handler();　　mHandler.post(new Runnable(){　　void run(){　　//执行代码...　　}　　});　　这个线程其实是在UI线程之内运行的，并没有新建线程。　　常见的新建线程的方法是：　　Thread thread = new Thread();　　thread.start();　　HandlerThread thread = new HandlerThread("string");　　thread.start();
本页面信息由华强电子网用户提供，如果涉嫌侵权，请与我们客服联系，我们核实后将及时处理。
设计应用分类
近日，中科院半导体所超晶格国家重点实验室研究员沈国震课题<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
您的访问请求被拒绝 403 Forbidden - ITeye技术社区
您的访问请求被拒绝
亲爱的会员，您的IP地址所在网段被ITeye拒绝服务，这可能是以下两种情况导致：
一、您所在的网段内有网络爬虫大量抓取ITeye网页，为保证其他人流畅的访问ITeye，该网段被ITeye拒绝
二、您通过某个代理服务器访问ITeye网站，该代理服务器被网络爬虫利用，大量抓取ITeye网页
请您点击按钮解除封锁&Handler Runnable和Thread之间的区别和联系 应用_百度知道
Handler Runnable和Thread之间的区别和联系 应用
提问者采纳
mt1.name+&;
mt1;+i)，然后第二个对象执行，其中native关键字表示可以调用操作系统的底层函数。在JDK的文档中可以发现，一种是实现Runnable接口？在JDK的安装路径下;
class MyThread implements Runnable{
private String name在java中可有两种方式实现多线程;i&lt：&quot.demo.);i++){
public MyThread(String name) {
super();+);线程b&
mt2，只有Thread类中才有;
}。那么为啥非要使用start()：public Thread(Runnable targer)此构造方法接受Runnable的子类实例;方法启动多线程呢。（start()可以协调系统的资源）.name+&quot，则会通过JVM找到run()方法;
}; 这样程序可以正常完成交互式运行：
}但是.runnable：package org，那么这样的技术成为JNI技术（java Native Interface）Runnable接口在实际开发中一个多线程的操作很少使用Thread类，一种是继承Thread类;线程a&
}public void run(){
for(int i=0，可以发现此方法中使用了private native void start0();+i).run();).run()，也就是说可以通过Thread类来启动Runnable实现的多线程。下面启动start()方法启动线程，而是通过Runnable接口完成;
public MyThread(String name) {
this；Thread类是在java.name =10.demo，通过此代码找到Thread中的start()方法的定义.name = name，这是此方法的局限。此时观察Thread类，有一个构造方法;
package org.demo,i=&
MyThread mt2=new MyThread(&
this.lang包中定义的：&quot.zip是全部的java源程序.println(&quot.
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread(&quot，此时结果很有规律;
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread(&);
class MyThread extends Thread{
private String name，先第一个对象执行：package org，并没有相互运行.
MyThread mt2=new MyThread(&i++){
S线程开始;线程b&quot，但是一个类只能继承一个父类;
} 例子;线程开始。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了;
public void run(){
for(int i=0;线程a&100。public interface Runnable{
public void run().println(&quot.start(),i=&quot。下面看例子; 但是在使用Runnable定义的子类中没有start()方法，一旦调用start()方法;+this.out
来自团队：
其他类似问题
为您推荐：
thread的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁Handler Runnable和Thread之间的区别和联系 应用_百度知道
Handler Runnable和Thread之间的区别和联系 应用
提问者采纳
mt1;);+this.thread,i=&
class MyThread extends Thread{
private String name.name =线程b&quotjava两种式实现线程种继承Thread类种实现Runnable接口;10.out.demo；Thread类
public MyThread(String name) {
super().run();
;线程始;+i);
public void run(){
for(int i=0.run().println(&
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread(&
MyThread mt2=new MyThread(&quot.线程a&quot.lang包定义类要继承Thread类同覆写本类run()实现线程操作类能继承父类局限面看例：package org.demo.name+&quot
来自团队：
其他类似问题
为您推荐：
thread的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁android中handler用法总结
一、Handler的定义:
Handler主要接收子线程发送的数据, 并用此数据配合主线程更新UI，用来跟UI主线程交互用。比如可以用handler发送一个message，然后在handler的线程中来接收、处理该消息，以避免直接在UI主线程中处理事务导致影响UI主线程的其他处理工作，Android提供了Handler作为主线程和子线程的纽带；也可以将handler对象传给其他进程，以便在其他进程中通过handler给你发送事件；还可以通过handler的延时发送message，可以延时处理一些事务的处理。
通常情况下，当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) ,
主线程为管理界面中的UI控件，进行事件分发。如果此时需要一个耗时的操作，例如:联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象,如果5秒钟还没有完成的话，会收到Android系统的一个错误提示"强制关闭".&
这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，但是当子线程中有涉及到操作UI的操作时，就会对主线程产生危险，也就是说，更新UI只能在主线程中更新，在子线程中操作是危险的.
这个时候，Handler就出现了来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传递)Message对象，(里面包含数据),
把这些消息放入主线程队列中，配合主线程进行更新UI。
二、Handler一些特点
handler可以分发Message对象和Runnable对象到主线程中,
每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),
也就是说Handler对象初始化后，就默认与对它初始化的进程的消息队列绑定，因此可以利用Handler所包含的消息队列，制定一些操作的顺序。
三、Handler中分发消息的一些方法
post(Runnable)
postAtTime(Runnable,long)
postDelayed(Runnable long)
&&&&&&&&&&&
post类方法允许你排列一个Runnable对象到主线程队列中
sendEmptyMessage(int)
sendMessage(Message)
sendMessageAtTime(Message,long)
sendMessageDelayed(Message,long)
&&&sendMessage类方法,
允许你安排一个带数据的Message对象到队列中，等待更新.
四、应用实例：
在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，用Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。类sendMessage(Message msg)方法实现发送消息的操作。
在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。
Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。
另外，Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&视频教程中的例子：
public&class&HandlerActivity&extends&Activity&{
&&&&//声明两个按钮控件
&&&&private&Button&startButton&=&
&&&&private&Button&endButton&=&
&&&&@Override&
&&&&public&void&onCreate(Bundle&savedInstanceState)&{
&&&&&&&&super.onCreate(savedInstanceState);
&&&&&&&&setContentView(R.layout.main);
&&&&&&&&//根据控件的ID得到代表控件的对象，并为这两个按钮设置相应的监听器
&&&&&&&&startButton&=&(Button)findViewById(R.id.startButton);
&&&&&&&&startButton.setOnClickListener(new&StartButtonListener());
&&&&&&&&endButton&=&(Button)findViewById(R.id.endButton);
&&&&&&&&endButton.setOnClickListener(new&EndButtonListener());
&&&&class&StartButtonListener&implements&OnClickListener{
&&&&&&&&@Override&
&&&&&&&&public&void&onClick(View&v)&{
&&&&&&&&&&&&//调用Handler的post方法，将要执行的线程对象添加到队列当中
&&&&&&&&&&&&handler.post(updateThread);
&&&&class&EndButtonListener&implements&OnClickListener{
&&&&&&&&@Override&
&&&&&&&&public&void&onClick(View&v)&{
&&&&&&&&&&&&handler.removeCallbacks(updateThread);
&&&&//创建一个Handler对象
&&&&Handler&handler&&=&new&Handler();
&&&&//将要执行的操作写在线程对象的run方法当中
&&&&Runnable&updateThread&=&&new&Runnable(){
&&&&&&&&@Override&
&&&&&&&&public&void&run()&{
&&&&&&&&&&&&System.out.println("UpdateThread");
&&&&&&&&&&&&//在run方法内部，执行postDelayed或者是post方法
&&&&&&&&&&&&handler.postDelayed(updateThread,&3000);
程序的运行结果就是每隔3秒钟，就会在控制台打印一行UpdateTread。这是因为实现了Runnable接口的updateThread对象进入了空的消息队列即被立即执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。
Handler和多线程
post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。
这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。&
public&class&HandlerTest2&extends&Activity&{
&&&&@Override&
&&&&protected&void&onCreate(Bundle&savedInstanceState)&{
&&&&&&&&//&TODO&Auto-generated&method&stub
&&&&super.onCreate(savedInstanceState);
&&&&setContentView(R.layout.main);
&&&&//打印了当前线程的ID &
&&&&System.out.println("Activity--&"&+&Thread.currentThread().getId());
&&&&//生成一个HandlerThread对象
&&&&HandlerThread&handlerThread&=&new&HandlerThread("handler_thread");
&&&&//在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程; &
&&&&handlerThread.start();
&&&&//将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。
&&&&&// HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程
，可以处理消息循环；&
其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是
一一对应的。
&&&&MyHandler&myHandler&=&new&MyHandler(handlerThread.getLooper());
&&&&Message&msg&=&myHandler.obtainMessage();
&&&&//将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象
&&&&Bundle&b&=&new&Bundle();
&&&&b.putInt("age",&20);
&&&&b.putString("name",&"Jhon");
&&&&msg.setData(b);
&&&&msg.sendToTarget();
&//将msg发送到myHandler
&&&&//定义类
&&&&class&MyHandler&extends&Handler{
&&&&public&MyHandler(){
&&&&&&&&&&&&
&&&&public&MyHandler(Looper&looper){
&&&&&&&&super(looper);
&&&&@Override&
&&&&public&void&handleMessage(Message&msg)&{
&&&&&&&&Bundle&b&=&msg.getData();
&&&&&&&&int&age&=&b.getInt("age");
&&&&&&&&String&name&=&b.getString("name");
&&&&&&&&System.out.println("age&is&"&+&age&+&",&name&is"&+&name);
&&&&&&&&System.out.println("Handler---&"&+&Thread.currentThread().getId());
&&&&&&&&System.out.println("handlerMessage");
这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。
这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。
另外再强调一遍，在UI线程（主线程）中：
mHandler=new Handler();
&&&&mHandler.post(new
Runnable(){
//执行代码..
这个线程其实是在UI线程之内运行的，并没有新建线程。
常见的新建线程的方法是：
Thread thread = new Thread();
thread.start();
HandlerThread thread = new HandlerThread("string");
thread.start();
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。

我要回帖

更多关于 java thread runnable 的文章

 

随机推荐