精华内容
下载资源
问答
  • java – Android线程runnable性能
    2021-06-08 11:07:32

    我想知道2种不同的启动runnables方法的性能和cpu / ram要求

    我有一些代码每10ms收集一次传感器数据,并将值插入后台线程的数据库中(使用单个线程执行程序). Executor服务创建如下:

    executor = Executors.newSingleThreadExecutor();

    一种方法是这样的……

    public void onSensorChanged(SensorEvent event) {

    //get sensor values

    //insert into database

    executor.execute(new Runnable(){

    //database insert code here

    });

    }

    我在教程中经常看到这个方法,但因为我每隔10ms就这样做,所以感觉资源密集,因为每次检测到传感器值更改时我都会创建一个新对象.这个新对象是否每10毫秒被覆盖一次?或者在创建新对象时它是否会占用越来越多的RAM?

    我已经重构了我的代码看起来更像这样:

    executor = Executors.newSingleThreadExecutor();

    myRunnable = new MyRunnable();

    class MyRunnable implements Runnable {

    public void run() {

    //database insert code here

    }

    }

    public void onSensorChanged(SensorEvent event) {

    //get sensor values

    //insert into database

    executor.execute(myRunnable);

    }

    我的想法是,我只实例化一个对象一次,而不是每次传感器改变时都这样做.我是否认为RAM的使用率低于之前的方法?有没有更有效/更好的方法来完成这项任务?

    更多相关内容
  • 作为替代,Android有强大的基础类,像HandlerThread,AsyncTask,IntentService。Thread和Runnable也是ThreadPoolExecutor的基础类。这个类可以自动管理线程和任务队列,甚至可以并行执行多线程。 定义一个实现...
  • 安卓Runnable接口解释

    2020-12-22 11:10:03
    本人才疏学浅,如有错误之处,还请见谅Runnable接口解释官方地址如下:官方解释如下The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread....

    本人才疏学浅,如有错误之处,还请见谅

    Runnable接口解释

    官方地址如下:

    官方解释如下

    The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread. The class must define a method of no arguments called run.

    This interface is designed to provide a common protocol for objects that wish to execute code while they are active. For example, Runnable is implemented by class Thread. Being active simply means that a thread has been started and has not yet been stopped.

    In addition, Runnable provides the means for a class to be active while not subclassing Thread. A class that implements Runnable can run without subclassing Thread by instantiating a Thread instance and passing itself in as the target. In most cases, the Runnable interface should be used if you are only planning to override the run() method and no other Thread methods. This is important because classes should not be subclassed unless the programmer intends on modifying or enhancing the fundamental behavior of the class.

    慢慢的翻译下

    这个Runnable 接口应该被那些有意实现单线程的例子继承

    这个例子必须定义一个没有参数的方法run

    这个接口设计出来为对象提供了一个一般的协议来执行活跃的代码(抱歉这段话我没有理解出来到底是什么意思) 举一个例子 Thread 继承了 Runnable后,Thread就是一个活的单线程例子.

    而且,Runnable提供了方法对一个类来成为活进程。而且没有子类化 Thread,一个类继承了Runnable可以运行而且不被子类化。Thread就是一个例证

    实例并将自身作为目标传入。在大多数请胯下,Runnable接口应该被使用,如果你只是计划去重写一下run() 方法 并不写Thread方法,这是重要的,因为类不应该被子类化。除非这个项目打算修饰或者加强 基本原则 表现关于这个类。

    下面是关于run方法的翻译

    public abstract void run ()

    When an object implementing interface Runnable is used to create a thread, starting the thread causes the object's run method to be called in that separately executing thread.

    The general contract of the method run is that it may take any action whatsoever.

    翻译:

    当一个类实现了Runnable接口时,Run方法就需要重写了。

    Run方法是为了在一个单独分开的单线程里面生成的一个方法.

    方法运行的一般约定是它可以采取任何操作。

    展开全文
  • android handler runnable使用实例(关键是内部run中停止)
  • android demo,Runnable异步线程的处理
  • 使用讲解2.1 使用步骤image特别注意:Java中真正能创建新线程的只有Thread类对象通过实现Runnable的方式,最终还是通过Thread类对象来创建线程所以对于 实现了Runnable接口的类,称为 线程辅助类;Thread类才是真正...

    目录

    6302705e7191

    image

    1. 简介

    6302705e7191

    image

    2. 使用讲解

    2.1 使用步骤

    6302705e7191

    image

    特别注意:

    Java中真正能创建新线程的只有Thread类对象

    通过实现Runnable的方式,最终还是通过Thread类对象来创建线程

    所以对于 实现了Runnable接口的类,称为 线程辅助类;Thread类才是真正的线程类

    2.2 具体使用

    // 步骤1:创建线程辅助类,实现Runnable接口

    class MyThread implements Runnable{

    ....

    @Override

    // 步骤2:复写run(),定义线程行为

    public void run(){

    }

    }

    // 步骤3:创建线程辅助对象,即 实例化 线程辅助类

    MyThread mt=new MyThread();

    // 步骤4:创建线程对象,即 实例化线程类;线程类 = Thread类;

    // 创建时通过Thread类的构造函数传入线程辅助类对象

    // 原因:Runnable接口并没有任何对线程的支持,我们必须创建线程类(Thread类)的实例,从Thread类的一个实例内部运行

    Thread td=new Thread(mt);

    // 步骤5:通过 线程对象 控制线程的状态,如 运行、睡眠、挂起 / 停止

    // 当调用start()方法时,线程对象会自动回调线程辅助类对象的run(),从而实现线程操作

    td.start();

    2.3 简便使用:匿名类

    很多情况下,开发者会选择一种更加方便的方法去创建线程:匿名类

    // 步骤1:通过匿名类 直接 创建线程辅助对象,即 实例化 线程辅助类

    Runnable mt = new Runnable() {

    // 步骤2:复写run(),定义线程行为

    @Override

    public void run() {

    }

    };

    // 步骤3:创建线程对象,即 实例化线程类;线程类 = Thread类;

    Thread mt1 = new Thread(mt, "窗口1");

    // 步骤4:通过 线程对象 控制线程的状态,如 运行、睡眠、挂起 / 停止

    mt1.start();

    2.3 区别

    2种方法本质相同,但是各有优劣势 & 不同的应用场景:

    大家可根据自己的需求场景来选择具体的使用方法

    6302705e7191

    image

    为了让大家理解更加深刻,下面例子我都会采用方法1 = 常规方式 来演示

    3. 实例应用

    实例1

    应用场景:创建两个线程-实现两个相同的耗时任务

    实例说明:实现2个窗口同时卖火车票;每个窗口卖100张,卖票速度都是1s/张

    具体实现

    main_activity.xml

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:paddingBottom="@dimen/activity_vertical_margin"

    android:paddingLeft="@dimen/activity_horizontal_margin"

    android:paddingRight="@dimen/activity_horizontal_margin"

    android:paddingTop="@dimen/activity_vertical_margin"

    tools:context="com.example.carson_ho.demoforrunnable.MainActivity">

    //设置一个按钮用以启动线程

    android:id="@+id/button"

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:text="点击开始卖票" />

    MainActivity.java

    package com.example.carson_ho.demoforrunnable;

    import android.os.Bundle;

    import android.support.v7.app.AppCompatActivity;

    import android.view.View;

    import android.widget.Button;

    public class MainActivity extends AppCompatActivity {

    //主布局中定义了一个按钮用以启动线程

    Button button;

    //步骤1:创建线程类,实现Runnable接口

    private class MyThread1 implements Runnable{

    private int ticket = 100;//一个窗口有100张票

    //在run方法里复写需要进行的操作:卖票速度1s/张

    @Override

    public void run(){

    while (ticket>0){

    ticket--;

    System.out.println(Thread.currentThread().getName() + "卖掉了1张票,剩余票数为:"+ticket);

    try {

    Thread.sleep(1000);//卖票速度是1s一张

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    }

    @Override

    protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);

    //Button按下时会开启一个新线程执行卖票

    button = (Button) findViewById(R.id.button);

    button.setOnClickListener(new View.OnClickListener() {

    @Override

    public void onClick(View v) {

    //步骤2:创建线程类的实例

    //创建二个线程,模拟二个窗口卖票

    MyThread1 mt1 = new MyThread1();

    MyThread1 mt2 = new MyThread1();

    Thread mt11 = new Thread(mt1, "窗口1");

    Thread mt22 = new Thread(mt2, "窗口2");

    //步骤3:调用start()方法开启线程

    //启动二个线程,也即是窗口,开始卖票

    mt11.start();

    mt22.start();

    }

    });

    }

    }

    测试结果

    6302705e7191

    image

    实例2

    应用场景:创建两个线程-实现两个不同的耗时任务

    实例说明:实现2个窗口同时卖火车票;每个窗口卖100张,但卖票速度不同:窗口1是1s/张,窗口2是3s/张

    具体实现

    main_activity.xml

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:paddingBottom="@dimen/activity_vertical_margin"

    android:paddingLeft="@dimen/activity_horizontal_margin"

    android:paddingRight="@dimen/activity_horizontal_margin"

    android:paddingTop="@dimen/activity_vertical_margin"

    tools:context="com.example.carson_ho.demoforrunnable2.MainActivity">

    //设置按钮用以启动线程

    android:id="@+id/button"

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:text="点击开始卖票" />

    MainActivity.java

    package com.example.carson_ho.demoforrunnable2;

    import android.support.v7.app.AppCompatActivity;

    import android.os.Bundle;

    import android.view.View;

    import android.widget.Button;

    public class MainActivity extends AppCompatActivity {

    //主布局中定义了一个按钮用以启动线程

    Button button;

    //步骤1:创建线程类,实现Runnable接口

    //由于需要实现两个不同的操作:卖票速度1s/张和3s/张

    //所以需要创建两个线程类并实现Runnable接口

    //第一个线程类:实现卖票速度1s/张操作

    private class MyThread1 implements Runnable{

    private int ticket = 100;//一个窗口有100张票

    //在run方法里复写需要进行的操作:卖票速度1s/张

    @Override

    public void run(){

    while (ticket>0){

    ticket--;

    System.out.println(Thread.currentThread().getName() + "卖掉了1张票,剩余票数为:"+ticket);

    try {

    Thread.sleep(1000);//卖票速度是1s一张

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    }

    //第二个线程类:实现卖票速度3s/张操作

    private class MyThread2 implements Runnable{

    private int ticket = 100;//一个窗口有100张票

    //在run方法里复写需要进行的操作:卖票速度3s/张

    @Override

    public void run(){

    while (ticket>0){

    ticket--;

    System.out.println(Thread.currentThread().getName() + "卖掉了1张票,剩余票数为:"+ticket);

    try {

    Thread.sleep(3000);//卖票速度是3s一张

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    }

    @Override

    protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);

    //Button按下时会开启一个新线程执行卖票

    button = (Button) findViewById(R.id.button);

    button.setOnClickListener(new View.OnClickListener() {

    @Override

    public void onClick(View v) {

    //步骤2:创建线程类的实例

    //分别实例化两个线程子类

    MyThread1 mt1 = new MyThread1();

    MyThread2 mt2 = new MyThread2();

    //创建二个线程,模拟二个窗口卖票

    Thread mt11 = new Thread(mt1, "窗口1");//卖票速度1s/张

    Thread mt22 = new Thread(mt2, "窗口2");//卖票速度3s/张

    //步骤3:调用start()方法开启线程

    //启动二个线程,也即是窗口,开始卖票

    mt11.start();

    mt22.start();

    }

    });

    }

    }

    测试结果

    由于卖票速度不同,所以窗口1卖3张时,窗口2才卖1张。

    6302705e7191

    image

    实例3

    应用场景:创建两个线程-实现一个耗时任务

    实例说明:实现2个窗口同时卖火车票;两个窗口一共卖100张,卖票速度均为1s/张

    具体实现

    main_activity.xml

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:paddingBottom="@dimen/activity_vertical_margin"

    android:paddingLeft="@dimen/activity_horizontal_margin"

    android:paddingRight="@dimen/activity_horizontal_margin"

    android:paddingTop="@dimen/activity_vertical_margin"

    tools:context="com.example.carson_ho.demoforrunnable3.MainActivity">

    //设置按钮用以启动线程

    android:id="@+id/button"

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:text="点击开始卖票" />

    MainActivity.java

    package com.example.carson_ho.demoforrunnable3;

    import android.support.v7.app.AppCompatActivity;

    import android.os.Bundle;

    import android.view.View;

    import android.widget.Button;

    public class MainActivity extends AppCompatActivity {

    //主布局中定义了一个按钮用以启动线程

    Button button;

    //步骤1:创建线程类,实现Runnable接口

    private class MyThread1 implements Runnable{

    private int ticket = 100;//两个窗口一共要卖100张票

    //在run方法里复写需要进行的操作:卖票速度1s/张

    @Override

    public void run(){

    while (ticket>0){

    ticket--;

    System.out.println(Thread.currentThread().getName() + "卖掉了1张票,剩余票数为:"+ticket);

    try {

    Thread.sleep(1000);//卖票速度是1s一张

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    }

    @Override

    protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);

    //Button按下时会开启一个新线程执行卖票

    button = (Button) findViewById(R.id.button);

    button.setOnClickListener(new View.OnClickListener() {

    @Override

    public void onClick(View v) {

    //步骤2:创建线程类的实例

    //因为是两个窗口共卖100张票,即共用资源

    //所以只实例化一个实现了Runnable接口的类

    MyThread1 mt = new MyThread1();

    //因为要创建二个线程,模拟二个窗口卖票

    Thread mt11 = new Thread(mt, "窗口1");

    Thread mt12 = new Thread(mt, "窗口2");

    //步骤3:调用start()方法开启线程

    //启动二个线程,也即是窗口,开始卖票

    mt11.start();

    mt12.start();

    }

    });

    }

    }

    测试结果

    实现了两个窗口一起卖100张票的目的

    6302705e7191

    image

    4. 与 “继承Thread类”对比

    在Java中,继承 Thread类和实现Runnable接口是实现多线程最常用的2种方法

    今天我们就来对比下这两种方法

    6302705e7191

    image

    5. 总结

    本文主要对多线程中实现 Runnable的用法进行了全面介绍

    展开全文
  • 本篇文章是对在Android中Handler Runnable与Thread的区别进行了详细的分析介绍,需要的朋友参考下
  • Runnable 并不一定是新开一个线程,比如下面的调用方法就是运行在UI主线程中的:Handler mHandler=new Handler();mHandler.post(new Runnable(){@Overridepublic void run() {// TODO Auto-generated method stub}})...

    Runnable 并不一定是新开一个线程,比如下面的调用方法就是运行在UI主线程中的:

    Handler mHandler=new Handler();

    mHandler.post(new Runnable(){

    @Override

    public void run() {

    // TODO Auto-generated method stub

    }

    });

    官方对这个方法的解释如下,注意其中的:“The runnable will be run on the user interface thread. ”

    boolean android.view.View .post(Runnable action)

    Causes the Runnable to be added to the message queue. The runnable will be run on the user interface thread.

    Parameters:

    action The Runnable that will be executed.

    Returns:

    Returns true if the Runnable was successfully placed in to the message queue. Returns false on failure, usually because the looper processing the message queue is exiting.

    我们可以通过调用handler的post方法,把Runnable对象(一般是Runnable的子类)传过去;handler会在looper中调用这个Runnable的Run方法执行。

    Runnable是一个接口,不是一个线程,一般线程会实现Runnable。

    这里我们看代码 mHandler.post(new Runnable(){  好像是new 了一个 interface, 其实是new的一个实现Runnable的匿名内部类(Inner Anonymous Class),这是很简练的写法。

    上面的代码可以看成是: new anonymousClass() implement interface{ [改写interface method]}

    Runnable是一个接口,不是一个线程,一般线程会实现Runnable。 所以如果我们使用匿名内部类是运行在UI主线程的,如果我们使用实现这个Runnable接口的线程类,则是运行在对应线程的。

    具体来说,这个函数的工作原理如下:

    View.post(Runnable)方法。在post(Runnable action)方法里,View获得当前线程(即UI线程)的Handler,然后将action对象post到Handler里。在Handler里,它将传递过来的action对象包装成一个Message(Message的callback为action),然后将其投入UI线程的消息循环中。在Handler再次处理该Message时,有一条分支(未解释的那条)就是为它所设,直接调用runnable的run方法。而此时,已经路由到UI线程里,因此,我们可以毫无顾虑的来更新UI。

    如下图,前面看到的代码,我们这里Message的callback为一个Runnable的匿名内部类

    这种情况下,由于不是在新的线程中使用,所以千万别做复杂的计算逻辑。

    参考资料:

    展开全文
  • 我需要更新一些UI,并通过使用runOnUiThread在UI线程内进行现在...Android似乎不允许直接使用数据。有没有一个优雅的方式来做到这一点?public void OnNewSensorData(Data data) {runOnUiThread(new Runnable() {pub...
  • private Handler handlerCount = new Handler();... Runnable runnable = new Runnable() { int testValue = 10; @Override public void run() { testValue++; handlerCount.postDelayed(runnable,1000); //.
  • 我正在尝试维护Webservice和Android应用程序之间的数据库同步.下面的代码工作正常,但我遇到了一些问题:>每次进入App的主页面时,都会启动一个新的无限过程.>这个过程永无止境任何人都可以按照我的意愿解释如何...
  • public abstract class StoppableRunnable implements Runnable {private volatile boolean mIsStopped = false;public abstract void stoppableRun();public void run() {setStopped(false);while(!mIsStopped) {...
  • 【声明】此文转载自:http://www.bubuko.com/infodetail-669650.html——尊重作者,知识无价,交流无限!一、先看图片,一目了然: 二、再看...23 import android.app.Activity;4 import android.os.Bundle;5 import...
  • 但有时候这种问题不太明显,比如在Runnable中通过Callback来更新UI,很容易就误以为是在UI线程中更新。问题描述简单Callback先来看一个简单的Callback的例子。layout:layout中有一个TextView,用来展示信息;以及一...
  • 回顾一下我们之前的 开启一个线程Thread并用进度条显示进度 小节,提到了这么一...什么?竟然能在 Worker Thread 直接修改 UI?太厉害了吧。 具体有关 Runnable 的东西现在还不谈,有兴趣可以先到网上搜一下相关资料。
  • Android上中断执行的Runnableimport android.content.Context;import android.os.Handler;...public abstract class CancelableThread implements Runnable {private volatile boolean mStopped;pr...
  • 我正在Android中实现Java ThreadPoolExecutor.我需要停止并从池中删除正在运行的任务.我已经使用submit(Runnable)和Future.cancel()方法实现了这一点.提交任务的代码如下:public Future> submitTask(Runnable ...
  • 原文:https://www.jianshu.com/p/95b186fbf192
  • // Handler.postDelayed(Runnable runnable, long delayMillis) 每隔delayMillis毫秒启动一次runnable 这行代码使得Runnable每隔100 ms(时间可以根据自己的情况设置)。因此Runnable代码最后为: runnable...
  • public class Handler extends Object A Handler allows you to send and process Message and Runnable objects associated with a thread's MessageQueue. Each Handler instance is associated with a single thr...
  • Android Runnable

    千次阅读 2013-03-28 10:19:24
    Runnable 并不一定是新开一个线程,比如下面的调用方法就是运行在UI主线程中的: Handler mHandler=new Handler(); mHandler.post(new Runnable(){ @Override public void run() { // TODO Auto-...
  • 什么要有,Callable接口和Runnable接口? 我们知道创建线程的方式有两种,一种是实现Runnable接口,另一种是继承Thread,但是这两种创建线程的方式都有个问题,执行完任务后无法获取返回结果,于是,就有了Callable...
  • android demo,使用Runnable和Handler的特性实现每个3s的定时器
  • 对于Android中异步的实现方式主要有以下三种: Java Thread、Runnable Android Handler、AsyncTask RxAndroid 以后会分别对三种方式进行说明,
  • Runnable接口实现多线程 创建线程另一途径就是用Thread类直接创建线程对象,构造方法是: Thread(Runnable traget) 构造方法中的参数是一个Runnable类型的接口 创建线程对象时必须向构造方法的参数传递一个实现...
  •  首先说明Android的CPU分配的最小单元是线程,Handler一般是在某个线程里创建的,因而Handler和Thread就是相互绑定的,一一对应。 而Runnable是一个接口,Thread是Runnable的子类。可以说,他俩都算一个进程。Han....
  • 第一种最常见实现延时操作的方法就是让类继承Runnable然后调用sleep的方法实现的延时操作 private class mythread implements Runnable{ @Override public void run() { try { Thread.sleep(1500); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 149,201
精华内容 59,680
关键字:

安卓runnable是什么