20

我习惯于用类似 JavaScript 或类似 Erlang 的语言编写代码，在那里我可以轻松地制作回调函数。现在我必须用 Java 写一些东西。我想出了如何像这样执行回调：

import java.util.*;

class Demo extends Thread{

    private int data;

    public void run(){
        ask_for_data(new Runnable(){
            public void run(){
                on_data();
            }
        });
    }

    public void on_data(){
        System.out.println("Async callback: " + data);
    }

    public void ask_for_data(final Runnable callback){
        System.out.println("2");
        Runnable r = new Runnable(){
            public void run(){
                data = get_data();
                new Thread(callback).start();
            }
        };
        new Thread(r).start();
    }

    public int get_data(){
        try{
            Thread.sleep(1000);
        } catch (Exception e) {};
        return 42;
    }

    public static void main(String[] args) {
        Demo d = new Demo();
        d.start();
    }
}

问题是：这是正确的方法吗？

4

2 回答 2

43

只需像这样将接口（回调实现）传递给您的可运行对象

interface Callback {
    void callback(); // would be in any signature
}

class MyThread implements Runnable {

    Callback c; 

    public MyThread(Callback c) {
        this.c = c;
    }

    public void run() {
        // some work
        this.c.callback(); // callback
    }
}

和一个关于线程所需的一切的简单 教程

于 2013-06-22T21:35:51.177 回答
7

您的代码非常复杂 - 您在内部扩展Thread、实现Runnable并在Runnable创建另一个Thread。这不是正确的做法。

接口Runnable可以被认为是一种命令设计模式——它是一个要完成的工作单元，它被设计为将“必须做什么”的逻辑与线程机制分开。

我不知道我是否正确地解决了您的问题，但据我了解，您只是尝试将一些参数传递给在单独线程中运行的回调。那么为什么不只是引入一些类实现Runnable（这是你要完成的工作单元）并通过构造函数传递一些工作参数。我的意思是如下所示：

public class MyUnitOfWork implements Runnable {
  private final Data data;

  public MyUnitOfWork(final Data data) {
    this.data = data;
  }

  public void run() {
    // do something with data
  }
}

后来：

Thread t = new Thread(new Data(/* something */));
t.start();
于 2013-06-22T21:50:21.713 回答