标签: runnable

我正在编写一个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()函数中修改(在主线程中声明)？

说我做以下......

// MyRunnable是我声明的类,它实现了Runnable.

MyRunnable r = new MyRunnable();
Thread t = new Thread(r);
t.start();

r = null;

将r设置为null有什么意义,就像我在上面的代码片段中一样？

可能重复:
Java:"实现Runnable"与"extends Thread"

Java提供了两个创建Thread类的选项,即通过实现Runnable或扩展Thread类.

我知道实现Runnable可能有很多原因,但不确定将Thread类扩展为创建自己的Thread类的场景？

你能否请我提供一些方案,其中扩展线程似乎是可行的或更好的选择或有利...

线程上有一个 问题,但没有回答我的问题

Thread t = new Thread(new Runnable() { public void run() {} });

我想用这种方式创建一个线程.run如果可能的话,如何将参数传递给方法？

编辑:要使我的问题具体,请考虑以下代码段:

for (int i=0; i< threads.length; i++) {
    threads[i] = new Thread(new Runnable() {public void run() {//Can I use the value of i in the method?}});
}

根据Jon的回答,它不起作用,因为i未被声明为final.

我有一个 JavaFX 应用程序，它可以在屏幕上为机器人（黑点）设置动画，并在它们去过的任何地方在浅灰色背景上绘制一条小白线（想想 Tron）。为此，我保留了机器人和所有白色像素的所有坐标。机器人的行为由实现 Runnable 的不同线程控制，并且可以在模拟运行时更改。机器人坐标存储在 HashMap 中，坐标是扩展 Point 的类，并使用双精度数来提高 x 和 y 值的内部计算精度。对于白点，我使用 HashMap，因为整数精度足以满足它们，因为它们不会移动并无限期地停留在屏幕上的 x 和 y 坐标处。

现在程序运行得很好，但是当存储白点点的 HashMap 增长时，应用程序的 JavaFX 线程崩溃的可能性就越来越大（想想看，更具体地说，它只是绘制机器人的画布。 ）控件的滑块保持响应，迭代的文本字段和 HashMap 的大小不断更新。但没有任何动画，几秒钟后画布变成白色。增加 Thread.sleep(ms) 的 ms 可以使程序更加稳定，但速度已经非常慢了。而且，这种情况在我的慢速学校上网本（运行 Win XP）上比在我的家用台式电脑（运行 Win7 64 位）上发生得更频繁、更快。例外也有不同的。对于台式电脑来说，如下：

java.lang.InternalError: Unrecognized PGCanvas token: 68
at com.sun.javafx.sg.prism.NGCanvas.renderStream(NGCanvas.java:651)
at com.sun.javafx.sg.prism.NGCanvas.renderContent(NGCanvas.java:320)
at com.sun.javafx.sg.prism.NGNode.doRender(NGNode.java:187)
at com.sun.javafx.sg.prism.NGNode.doRender(NGNode.java:39)
at com.sun.javafx.sg.BaseNode.render(BaseNode.java:1145)
at com.sun.javafx.sg.prism.NGGroup.renderContent(NGGroup.java:204)
at com.sun.javafx.sg.prism.NGRegion.renderContent(NGRegion.java:420)
at com.sun.javafx.sg.prism.NGNode.doRender(NGNode.java:187)
at com.sun.javafx.sg.prism.NGNode.doRender(NGNode.java:39)
at com.sun.javafx.sg.BaseNode.render(BaseNode.java:1145)
at com.sun.javafx.tk.quantum.ViewPainter.doPaint(ViewPainter.java:117)
at com.sun.javafx.tk.quantum.AbstractPainter.paintImpl(AbstractPainter.java:175)
at com.sun.javafx.tk.quantum.PresentingPainter.run(PresentingPainter.java:73)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
at java.util.concurrent.FutureTask$Sync.innerRunAndReset(FutureTask.java:351)
at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:178)
at com.sun.prism.render.RenderJob.run(RenderJob.java:37)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
at …

是否可以在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);
        }


    }

假设我有一些工作单元需要完成,我想相对于我的应用程序的其余部分进行异步操作,因为它可能需要很长时间,例如10秒到2分钟.要做到这一点,我正在考虑两个选择:

1. 使用简单的触发器设置Quartz作业,只能触发一次并尽快触发.
2. 创建一个Runnable实例,将其移交给一个Thread,然后调用run();.

在上述情况下,我有以下问题:

1. 什么使用Quartz作业让我觉得线程没有？
2. 什么使用runable让我使用石英作业不？
3. 就最佳实践而言,应该使用什么标准来确定此用例的Quartz作业和runnables？

从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的角色？

我是Java的新手,我正在阅读多线程的概念,在进行多线程的各种实现时,我经历了这两个概念.这在Java问题中Runnable和Callable接口之间的区别指出了两者之间的区别以及使用的位置.

我怀疑Callable是否能够完成Runnable的所有功能,为什么这么多人使用Runnable而不是可调用？与Runnable Inteface相比,实现Callable接口是否有额外的开销？

在 oppo f1 5.1 版本中运行应用程序时，logcat 显示以下错误：

ANR_LOG: >>> msg's executing time is too long 

Blocked msg = { when=-15s421ms what=0 target=android.view.Choreographer$FrameHandler callback=android.view.Choreographer$FrameDisplayEventReceiver } , cost  = 15162 ms
 >>>Current msg List is:
    Current msg <1>  = { when=-15s412ms what=0 target=android.os.Handler callback=android.support.v4.content.res.ResourcesCompat$FontCallback$2 }
    Current msg <2>  = { when=-15s410ms what=0 target=android.os.Handler callback=android.support.v4.content.res.ResourcesCompat$FontCallback$2 }
    Current msg <3>  = { when=-15s408ms what=0 target=android.os.Handler callback=android.support.v4.content.res.ResourcesCompat$FontCallback$2 }
    Current msg <4>  = { when=-15s405ms what=0 target=android.os.Handler callback=android.support.v4.content.res.ResourcesCompat$FontCallback$2 }
    Current msg <5>  = { when=-15s403ms what=0 target=android.os.Handler …