我有一个关于如何ExecutorService在Java中工作的基本问题.
很难看出简单地创建Threads并行执行某些任务和将每个任务分配给它们之间的区别ThreadPool.
使用起来ExecutorService也非常简单和有效,所以我想知道为什么我们不一直使用它.
这只是一种比另一种方式更快地执行其工作的问题吗？
这里有两个非常简单的例子来说明两种方式之间的区别:
使用执行程序服务:Hello World(任务)
static class HelloTask implements Runnable {
String msg;
public HelloTask(String msg) {
this.msg = msg;
}
public void run() {
long id = Thread.currentThread().getId();
System.out.println(msg + " from thread:" + id);
}
}
使用执行程序服务:Hello World(创建执行程序,提交)
static class HelloTask {
public static void main(String[] args) {
int ntasks = 1000;
ExecutorService exs = Executors.newFixedThreadPool(4);
for (int i=0; i<ntasks; i++) {
HelloTask t = new HelloTask("Hello from …我知道这 implements Runnable比extends Thread Java线程更受欢迎,因为它允许我们在需要时扩展其他类.但如果是这样的话,它extends Thread也有自己的优势implements Runnable,如果是的话,这些优势是什么？
我有一个名为MyThread扩展Thread类并实现该run()函数的类.当我想运行它时,我有两种方法:
new MyThread().start()(new Thread(new MyThread)).start();任何人都能区分出来吗？
"有一次,当你知道线程即将退出时,吞下一个中断是可以接受的.只有在调用可中断方法的类是a的一部分而
Thread不是Runnable[...]的一部分时,才会出现这种情况.
我现在总是Runnable为我的线程实现.给出这样的Runnable实现:
public class View() implements Runnable {
@Overload
public void run(){
Thread worker = new Thread(new Worker());
worker.start();
do{
try{
TimeUnit.SECONDS.sleep(3);
updateView();
}catch(InterruptedException e){
worker.interrupt();
// Thread.currentThread().interrupt();
return;
}
}while(true);
}
protected void updateView(){
// …
}
}
Thread.currentThread().interrupt();在return;发言之前是否真的有必要打电话？是不是return;已经执行干净的enaugh退出？叫它有什么好处？文章指出应该这样做,因为否则"[......]调用堆栈上面的代码将无法找到它[...]".Thread.State.TERMINATED在应用程序关闭时,没有它的中断标志设置的线程有什么好处？你能给我一个例子,在这个例子中,Runnable出于合理的原因检查中断标志以外的代码吗？
顺便说一句,它是一个更好的代码设计,Thread而不是实现Runnable？
我是Java的线程编程的新手,因此这个基本问题.(我检查过,但以前找不到这个问题)
我读到可以通过继承Thread类或通过实现Runnable接口来创建线程.我看到一个代码同时出现在同一个类中.
public class ThreadExample extends Thread implements Runnable {
}
我想知道这种情况会是什么样的,如果有什么优势,那是什么呢.
是否有可能创建一个单独的后台线程,它将分别做一些东西？我已经尝试了以下程序,但它没有像我期望的那样工作.
public class Test {
private static class UpdaterThread extends Thread {
private final int TIMEOUT = 3000;
public void run() {
while (true) {
try {
Thread.sleep(TIMEOUT);
System.out.println("3 seconds passed");
} catch (InterruptedException ex) {
}
}
}
}
/**
* @param args
* the command line arguments
*/
public static void main(String[] args) {
try {
Thread u = new UpdaterThread();
u.start();
while (true) {
System.out.println("--");
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
我期望每3秒"3秒钟过去"将打印在多个" - …
我知道有两种方法可以在java中使用线程:
我也知道实现 Runable比扩展Thread更好 .
但为什么有两种方式 - 为什么不只有一种？
如果实现Runnable是一种更好的方法,为什么还有其他选择呢？
只有一个选项会有什么问题？
尽管通读从线程和Runnable接口之间的差异显著这里,我遇到了一个区别是:
当您扩展Thread类时,每个线程都会创建唯一对象并与之关联.在哪里
实现Runnable时,它将同一对象共享给多个线程..
有代码给:
class ImplementsRunnable implements Runnable {
private int counter = 0;
public void run() {
counter++;
System.out.println("ImplementsRunnable : Counter : " + counter);
}
}
class ExtendsThread extends Thread {
private int counter = 0;
public void run() {
counter++;
System.out.println("ExtendsThread : Counter : " + counter);
}
}
public class ThreadVsRunnable {
public static void main(String args[]) throws Exception {
//Multiple threads share the same object.
ImplementsRunnable rc = new ImplementsRunnable();
Thread …作为初学者,我正在阅读有关在Java中实现多线程的两种方法.
我在SO和许多其他线程上阅读了这个帖子.
据说这是
"prefer runnable",仅在您专门处理Thread的行为时才扩展线程.
有人可以通过为我提供一小段片段来帮助我理解这一行,从而解释我对Thread行为的专业意义.