标签: runnable

我写了以下代码:

import java.util.Calendar;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

class Voter {   
public static void main(String[] args) {
    ScheduledThreadPoolExecutor stpe = new ScheduledThreadPoolExecutor(2);
    stpe.scheduleAtFixedRate(new Shoot(), 0, 1, TimeUnit.SECONDS);
}
}

class Shoot implements Runnable {
Calendar deadline;
long endTime,currentTime;

public Shoot() {
    deadline = Calendar.getInstance();
    deadline.set(2011,6,21,12,18,00);
    endTime = deadline.getTime().getTime();
}

public void work() {
    currentTime = System.currentTimeMillis();

    if (currentTime >= endTime) {
        System.out.println("Got it!");
        func();
    } 
}

public void run() {
    work();
}

public void func() {
    // function called when time …

我需要一点帮助,每秒从Runnable/Handler更新我的UI.我正在使用此代码:

Runnable runnable = new Runnable() {
        @Override
        public void run() {
                handler.post(new Runnable() {
                    @Override
                    public void run() {

                        prBar.setProgress(myProgress);
                        y = (double) ( (double) myProgress/ (double) RPCCommunicator.totalPackets)*100;
                        txtInfoSync1.setText(Integer.toString((int)y) + "%");
                        prBar.setMax(RPCCommunicator.totalPackets);

                        int tmp = totalBytesReceived - timerSaved;
                        Log.w("","totalBytesReceived : "+totalBytesReceived + " timerSaved : "+timerSaved );
                        Log.w("","tmp : "+tmp);

                        if (avgSpeedCalc.size() > 10)
                        {
                            avgSpeedCalc.remove(0);
                        }

                        avgSpeedCalc.add(tmp);

                        int x = 0;

                        for (int y=0;y<avgSpeedCalc.size();y++)
                        {
                            x += avgSpeedCalc.get(y);
                            Log.d("","x : "+x);
                        }

                        x = Math.round(x/avgSpeedCalc.size());
                        Log.e("","x : "+x); …

我想每5秒运行一次代码.我无法通过处理程序实现此目的.怎么能在Kotlin完成？这是我到目前为止所拥有的.另外需要注意的是,变量Timer_Preview是一个Handler.

我想通过bundle将Runnable传递给一个活动,这样runnable必须在onCreate触发时运行.我编写了一个实现Serializable的类,但它会导致异常:"java.lang.RuntimeException: Parcelable encountered IOException writing serializable object".我的代码在这里:

package some.company.common;

import java.io.Serializable;

public class SerializedRunnable implements Serializable, Runnable {

    private static final long serialVersionUID = 6641813629033240205L;

    public SerializedRunnable() {
    }

    private Runnable runnable;

    public SerializedRunnable(Runnable runnable) {
        this.runnable = runnable;
    }

    @Override
    public void run() {
        this.runnable.run();
    }

}

基本上我想使用SurfaceView进行动画制作.因此该类实现了Runnable.为了实验,我想绘制一个圆圈.但是,它只显示黑屏.

我已经好几天了.如果有人能提供帮助,真的很感激.

MainActivity类

public class MainActivity extends Activity {

private Bitmap Liquid;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature (Window.FEATURE_NO_TITLE);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN);

    DrawStripFrame D1 = new DrawStripFrame(this);
    setContentView(D1);

DrawStripFrame类

public class DrawStripFrame extends SurfaceView implements Runnable{

private SurfaceHolder holder;
private boolean running = true;

public DrawStripFrame (Context context){
    super (context);
    holder = getHolder();
}

@Override
public void run(){

        while(running){         
            if(holder.getSurface().isValid()){
                Canvas c = holder.lockCanvas();
                c.drawARGB(0, 0, 0, 0);
                Paint redPaint = new Paint();
                redPaint.setColor(Color.RED);
                c.drawCircle(100, 100, 30, redPaint);
                holder.unlockCanvasAndPost(c); …

几天以来,我试图弄清楚如果我执行代码会发生什么

void function(){

  //somePreExecutionCode
  new Handler().post(new Runnable(){
    @Override 
    public void run(){
       //someCode
    }
  });
}

它似乎没有阻止UI,所以调用function()的按钮在someCode完成之前不会卡在点击的位置.但是如果somePreExecutionCode启动了progressBar,那么当someCode完成时,progressBar会在完全相同的时刻显示.我知道,有AsyncTasks,但还有其他可能吗？

最重要的是什么

new Handler().post 

和

View.post

？

我希望从一个方法得到一个结果可能需要一段时间才能完成并且实际上不会返回该对象,所以我想尽可能有效地处理它.这是我想要实现的一个例子:

    public static void main (String[] args) {
        Object obj = someMethod();

        System.out.println("The object is" + obj + ", wooh!");
    }

    public void callObject() {
        // Sends request for the object
    }

    public void receiveObject(Object object) {
        // Received the object
    }

    public Object someMethod() {
        callObject();
        // delay whilst the object is being received
        // return received object once received, but how?
    }

方法callObject将调用获取对象,但是在对象中调用另一个方法.我希望someMethod()能够调用该对象,然后返回它最终收到的内容,即使实际调用和接收是单独的方法.

我已经研究过使用FutureTasks和Callables,我认为这是前进的方向,我只是不太确定如何实现它.

对不起,如果我没有解释得太好,我会在必要时提供更多信息.

谢谢!

我正在编写一个Android应用程序,并使用工作线程来处理某些信息.阅读完我的代码后,我现在不确定它是否是线程安全的.

我已经编写了我的代码的简化版本,我省略了Handler用于与主线程进行通信的对象,显然是进程本身.

public class myClass implements Runnable
{
    private String myString;

    @Override
    public void run()
    {
        myString = "Some Value";
    }
}

通过运行类似于此的东西来调用它.

myClass class = new myClass();
Thread thread = new Thread(class);
thread.start()

那么,这个代码是不是线程安全的,因为我myString在run()函数中修改(在主线程中声明)？

是否可以在Activity.runOnUiThread()方法后返回一个值.

runOnUiThread(new Runnable() {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        int var = SOMETHING;

        // how to return var value.         
    }
});

在这篇文章中,我看到在Runnable.run()方法之后返回值是不可能的.但是如何使用(实现)另一个接口并在执行后返回一个值.

希望一切都清楚.

编辑

可以帮助别人.

我使用D @ Zapl的解决方案,并在Callable类构造函数中传递一个参数,如下所示:

class MyCallable implements Callable<MyObject> {

        int param;

        public MyCallable (int param) {
            // TODO Auto-generated constructor stub
            this.param = param;
        }

        @Override
        public MyObject call() throws Exception {
            // TODO Auto-generated method stub
            return methodReturningMyObject(this.param);
        }


    }

从Java核心库问题中的GoF设计模式的例子中可以看出

java.lang.Runnable的所有实现都是Command模式的示例.

根据我对Command模式的理解,

客户端调用Invoker => Invoker调用ConcreteCommand => ConcreteCommand调用Receiver方法,该方法实现抽象的Command方法.

看看这个工作示例

从命令图案UML图本文如下所示.

看看这段代码:

public class ThreadCommand{
    public static void main(String args[]){
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}
class MyRunnable implements Runnable{
    public void run(){
        System.out.println("Running:"+Thread.currentThread().getName());
    }
}

1. ThreadCommand是Client
2. Runnable接口是Command
3. MyRunnable是ConcreteCommmand
4. 线程是祈求与start()方法调用的ConcreteCommand implementaiton(它调用run()方法)

Receiver是否在这里失踪？或者MyRunnable是否扮演ConcreteCommand和Receiver的角色？