标签: runnable

从我在Java中使用线程的时间开始,我发现了这两种编写线程的方法:

用implements Runnable:

public class MyRunnable implements Runnable {
    public void run() {
        //Code
    }
}
//Started with a "new Thread(new MyRunnable()).start()" call

或者,用extends Thread:

public class MyThread extends Thread {
    public MyThread() {
        super("MyThread");
    }
    public void run() {
        //Code
    }
}
//Started with a "new MyThread().start()" call

这两个代码块有什么显着差异吗？

在Java中设计并发线程时使用Runnable和Callable接口有什么区别,为什么要选择一个而不是另一个呢？

假设我们有这两个Runnables:

class R1 implements Runnable {
    public void run() { … }
    …
}

class R2 implements Runnable {
    public void run() { … }
    …
}

那么这有什么区别:

public static void main() {
    R1 r1 = new R1();
    R2 r2 = new R2();

    r1.run();
    r2.run();
}

还有这个:

public static void main() {
    R1 r1 = new R1();
    R2 r2 = new R2();
    Thread t1 = new Thread(r1);
    Thread t2 = new Thread(r2);

    t1.start();
    t2.start();
}

假设我有一个利用Executor框架的应用程序

Executors.newSingleThreadExecutor().submit(new Runnable(){
    @Override
    public void run(){
        // do stuff
    }
}

当我在调试器中运行此应用程序时,将使用以下(默认)名称创建一个线程:Thread[pool-1-thread-1].正如您所看到的,这不是非常有用,据我所知,该Executor框架没有提供一种简单的方法来命名创建的线程或线程池.

那么,如何为线程/线程池提供名称呢？例如,Thread[FooPool-FooThread].

我需要一个"Runnable接受一个参数",虽然我知道这样的runnable并不存在.

这可能指出我的应用程序设计中的根本缺陷和/或疲惫的大脑中的心理障碍,所以我希望在这里找到关于如何完成以下内容的一些建议,而不违反基本的OO原则:

  private Runnable mOneShotTask = new Runnable(String str) {
    public void run(String str) {
       someFunc(str);
    }
  };  

知道如何完成上述内容吗？

用外行人的话来说,Java中的"runnable"是什么？我是高中的AP编程学生,他的任务是做研究,或者从别人那里寻找"runnable"是什么(我们刚刚进入OOP,还没有触及线程).

我在实现Runnable的类中调用run()的方法被设计为抛出异常.

但Java编译器不会让我这样做,并建议我用try/catch包围它.

问题是,通过try/catch包围它,我使特定的 run()无用.我确实想抛出那个例外.

如果我throws为run()本身指定,编译器会抱怨Exception is not compatible with throws clause in Runnable.run().

通常我完全没有让 run()抛出异常.但我有独特的情况,我必须具备该功能.

如何解决这个限制？

我有一个"开放"的动画,Handler.postDelayed(Runnable, delay)用于在短暂延迟后触发"关闭"动画.但是,在打开和关闭之间的时间内,可能会有一个由点击触发的动画.

我的问题是,如何取消处理程序中的"关闭"动画？

为什么以下第一个示例不起作用？

• run(R::new);方法R.run未被调用.
• run(new R());方法R.run 被调用.

这两个例子都是可编译的.

public class ConstructorRefVsNew {

  public static void main(String[] args) {
      new ConstructorRefVsNew().run(R::new);
      System.out.println("-----------------------");
      new ConstructorRefVsNew().run(new R());
  }

  void run(Runnable r) {
      r.run();
  }

  static class R implements Runnable {

      R() {
          System.out.println("R constructor runs");
      }

      @Override
      public void run() {
          System.out.println("R.run runs");
      }
  }
}

输出是:

  R constructor runs
  -----------------------
  R constructor runs
  R.run runs

在第一个示例中,R调用构造函数,它返回lambda(不是对象):

但是,如何成功编译示例怎么可能呢？

我有疑问让我感到困惑.

想象一下,我想在另一个线程中做一些事情,比如获取GPS /位置内容,这些内容按照SDK文档中的建议,必须使用后台线程.

所以这里有一个问题:两者之间有什么区别

1. Thread通过AND在后台创建AsyncTask

2. 创建Thread thread1 = new Thread(new Runnable()......并实施run()？