`
liyanhui
  • 浏览: 349735 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

关于线程thread和runnable

    博客分类:
  • java
阅读更多
Runnable的意思是,你要用代码——也就是run( )方法——来描述一个处理过程,而不是创建一个表示这个处理过程的对象。在如何理解线程方面,一直存在着争议。这取决于,你是将线程看作是对象还是处理过程[68]。如果你认为它是一个处理过程,那么你就摆脱了"万物皆对象"的OO教条。但与此同时,如果你只想让这个处理过程掌管程序的某一部分,那你就没理由让整个类都成为Runnable的。有鉴于此,用内部类的形式将线程代码隐藏起来,通常是个更明智的选择。就像下面这段代码:

//: c13:ThreadVariations.java
// Creating threads with inner classes.
import com.bruceeckel.simpletest.*;
// Using a named inner class:
class InnerThread1 {
  private int countDown = 5;
  private Inner inner;
  private class Inner extends Thread {
    Inner(String name) {
      super(name);
      start();
    }
    public void run() {
      while(true) {
        System.out.println(this);
        if(--countDown == 0) return;
        try {
          sleep(10);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    }
    public String toString() {
      return getName() + ": " + countDown;
    }
  }
  public InnerThread1(String name) {
    inner = new Inner(name);
  }
}
// Using an anonymous inner class:
class InnerThread2 {
  private int countDown = 5;
  private Thread t;
  public InnerThread2(String name) {
    t = new Thread(name) {
      public void run() {
        while(true) {
          System.out.println(this);
          if(--countDown == 0) return;
          try {
            sleep(10);
          } catch (InterruptedException e) {
            throw new RuntimeException(e);
          }
        }
      }
      public String toString() {
        return getName() + ": " + countDown;
      }
    };
    t.start();
  }
}
// Using a named Runnable implementation:
class InnerRunnable1 {
  private int countDown = 5;
  private Inner inner;
  private class Inner implements Runnable {
    Thread t;
    Inner(String name) {
      t = new Thread(this, name);
      t.start();
    }
    public void run() {
      while(true) {
        System.out.println(this);
        if(--countDown == 0) return;
        try {
          Thread.sleep(10);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    }
    public String toString() {
      return t.getName() + ": " + countDown;
    }
  }
  public InnerRunnable1(String name) {
    inner = new Inner(name);
  }
}
// Using an anonymous Runnable implementation:
class InnerRunnable2 {
  private int countDown = 5;
  private Thread t;
  public InnerRunnable2(String name) {
    t = new Thread(new Runnable() {
      public void run() {
        while(true) {
          System.out.println(this);
          if(--countDown == 0) return;
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            throw new RuntimeException(e);
          }
        }
      }
      public String toString() {
        return Thread.currentThread().getName() +
          ": " + countDown;
      }
    }, name);
    t.start();
  }
}
// A separate method to run some code as a thread:
class ThreadMethod {
  private int countDown = 5;
  private Thread t;
  private String name;
  public ThreadMethod(String name) { this.name = name; }
  public void runThread() {
    if(t == null) {
      t = new Thread(name) {
        public void run() {
          while(true) {
            System.out.println(this);
            if(--countDown == 0) return;
            try {
              sleep(10);
            } catch (InterruptedException e) {
              throw new RuntimeException(e);
            }
          }
        }
        public String toString() {
          return getName() + ": " + countDown;
        }
      };
      t.start();
    }
  }
}
public class ThreadVariations {
  private static Test monitor = new Test();
  public static void main(String[] args) {
    new InnerThread1("InnerThread1");
    new InnerThread2("InnerThread2");
    new InnerRunnable1("InnerRunnable1");
    new InnerRunnable2("InnerRunnable2");
    new ThreadMethod("ThreadMethod").runThread();
    monitor.expect(new String[] {
      "InnerThread1: 5",
      "InnerThread2: 5",
      "InnerThread2: 4",
      "InnerRunnable1: 5",
      "InnerThread1: 4",
      "InnerRunnable2: 5",
      "ThreadMethod: 5",
      "InnerRunnable1: 4",
      "InnerThread2: 3",
      "InnerRunnable2: 4",
      "ThreadMethod: 4",
      "InnerThread1: 3",
      "InnerRunnable1: 3",
      "ThreadMethod: 3",
      "InnerThread1: 2",
      "InnerThread2: 2",
      "InnerRunnable2: 3",
      "InnerThread2: 1",
      "InnerRunnable2: 2",
      "InnerRunnable1: 2",
      "ThreadMethod: 2",
      "InnerThread1: 1",
      "InnerRunnable1: 1",
      "InnerRunnable2: 1",
      "ThreadMethod: 1"
    }, Test.IGNORE_ORDER + Test.WAIT);
  }
} ///:~
InnerThread1创建了一个继承Thread的非匿名内部类,然后在构造函数里创建了一个这个内部类的实例。如果你要用宿主类的方法访问内部类的特殊功能(新方法)的话,这种做法会比较好。但是绝大多数情况下,创建线程的目的,只是要用它的Thread功能,所以不必创建非匿名的内部类。InnerThread2就演示了这个方案:在构造函数里面创建一个继承Thread的匿名内部类,然后把它上传给Thread的reference t。宿主类的其它方法可以通过t访问Thread的接口,它们无需知道这个对象的确切类型。

第三和第四个类重复了前两个类,不过它们都不是Thread,而是Runnable。这么做是想告诉你,用Runnable什么便宜也没占到,相反代码还稍微复杂了一些(也更难读了一些)。所以结论是,除非迫不得已只能用Runnable,否则我会选Thread。

ThreadMethod演示了怎样在方法的内部创建线程。要运行线程的时候就调用方法,线程启动之后方法就返回。如果这个线程不那么重要,只是做一些辅助操作的话,那么相比在构造函数里启动线程,这个方法或许会更好一些
分享到:
评论

相关推荐

    thread 线程类 实现runnable接口

    Thread 线程类是 Java 中 Thread 和 Runnable 接口的实现,它提供了线程的基本操作和管理。下面是对 Thread 类的详细介绍: 1. Runnable 接口 Runnable 接口是 Thread 类的基类,它提供了 run() 方法,该方法是...

    多线程的Runnable_和thread有什么区别

    ### 多线程的Runnable与Thread的区别 在Java中实现多线程有两种主要方式:一种是继承`Thread`类;另一种是实现`Runnable`接口。本文将深入探讨这两种方法的区别,帮助初学者更好地理解并选择适合场景的多线程实现...

    java 多线程Thread与runnable的区别

    在 Java 中,实现多线程有两种方法:继承 Thread 类和实现 Runnable 接口。在本文中,我们将对这两种方法进行详细的介绍和对比。 继承 Thread 类 继承 Thread 类是 Java 中最基本的多线程实现方法。 Thread 类提供...

    java线程_Thread_Runnable

    Java提供了两种创建线程的方式:继承Thread类和实现Runnable接口。 1. 继承Thread类创建线程: 当你选择继承Thread类时,你需要创建一个新的类,这个类扩展自Thread类。Thread类已经实现了Runnable接口,所以你不...

    JAVA多线程Thread和Runnable的实现

    有两种主要的方式可以实现多线程:继承`Thread`类和实现`Runnable`接口。这两种方法各有特点,适用于不同的场景。 **继承Thread类** 当一个类直接继承自`Thread`类时,这个类本身就成为一个线程实体。你可以重写`...

    【java学习记录】11.多线程实现阶乘计算(Thread类和Runnable接口)

    本篇文章将深入探讨如何利用`Thread`类和`Runnable`接口来实现阶乘计算的多线程解决方案。阶乘计算是数学中的一个概念,对于非负整数n,其阶乘表示为所有小于等于n的正整数的乘积,记作n!。 首先,我们来看如何使用...

    认识Thread和Runnable

    Thread 和 Runnable 是实现 Java 多线程的两种方式,Runnable 是接口,Thread 是类,建议使用 Runnable 实现 Java 多线程,不管如何,最终都需要通过 thread.start() 来使线程处于可运行状态。 Thread 的 start 和 ...

    JAVA中使用Thread类和Runnable接口创建多线程

    在Java中创建线程有两种方法:使用Thread类和使用Runnable接口。在使用Runnable接口时需要建立一个Thread实例。因此,无论是通过Thread类还是Runnable接口建立线程,都必须建立Thread类或它的子类的实例。

    详解Java中Thread 和Runnable区别

    Java中Thread和Runnable是两个不同的概念,它们都是Java中的线程机制,但是它们之间有着本质的区别。 Thread是Java中的一个类,而Runnable是一个接口。Thread类实现了Runnable接口,Runnable接口只有一个run()方法,...

    Java多线程技术 线程的死锁,详细阐述了多线程的两种实现方法: 由Thread类派生子类;实现Runnable接口

    ### Java多线程技术详解 #### 一、引言 多线程编程是现代软件开发中不可或缺的一部分,尤其是在Java这样的面向对象编程语言中尤为...同时,合理地处理线程间的同步和避免死锁也是构建稳定、可靠的多线程应用的关键。

    Java中Runnable和Thread的区别

    在Java编程语言中,多线程的实现有多种方式,其中最常见的是通过继承`Thread`类和实现`Runnable`接口。这两种方法各有其特点和适用场景,理解它们之间的区别对于编写高效、可维护的多线程应用至关重要。 ### 继承...

    实现Runnable接口创建多线程.docx

    在Java编程语言中,创建线程有两种主要方式:继承`Thread`类和实现`Runnable`接口。由于Java的单继承特性,当一个类需要继承其他类时,就不能再直接继承`Thread`,这时实现`Runnable`接口就成为创建线程的优选方案。...

    Java有两种实现多线程的方式:通过Runnable接口、通过Thread直接实现,请掌握这两种实现方式,并编写示例程序。

    在Java中,实现多线程的两种主要方式分别是:**通过继承`Thread`类** 和 **实现`Runnable`接口**。下面将详细介绍这两种方式,并提供相应的示例程序。 #### 一、通过继承`Thread`类实现多线程 在Java中,可以通过...

    java多线程Runnable实例

    `Runnable`接口是Java实现多线程的一种方式,通过实现`Runnable`接口并创建`Thread`对象,可以轻松地创建并运行多线程。`TestRunnable.java`文件展示了这一过程,同时也提醒我们在实际开发中要注意线程同步和通信,...

    线程Runnable的实现

    在一个线程中求100以内的偶数,求出一个偶数后休眠一个随机时间在(1-300毫秒之间).在另一个线程中求奇数,求出一个奇数后也休眠一个随机时间(1-300毫秒之间).输出数据时应有提示,指明是哪个线程输出的数据 用实例...

    francistao#LearningNotes#Thread和Runnable实现多线程的区别1

    在第二种方法中,由于3个Thread对象共同执行一个Runnable对象中的代码,因此可能会造成线程的不安全,比如可能ticket会输出-1(如果我们Syste

    java多线程、通信机制、Thread类以及Runnable接口间的使用实例

    1. 写两个线程,一个线程打印1-52,另一个线程打印字母A-Z。打印顺序为12A34B56C……5152Z。 学习线程之间的通信协调关系。 2. 使用 runnable 接口实现按两... 使用继承Thread类方式和实现Runnable接口两种方式实现。

    Android 多线程下载简单demo之Runnable

    本篇将基于`Runnable`接口提供一个简单的多线程下载示例,帮助开发者理解如何在Android中实现这一功能。 首先,我们要明白在Android中,主线程(UI线程)负责处理用户交互和更新界面,因此,长时间的网络请求或计算...

    实现Runnable接口和继承Thread类两种方式实现在屏幕上随机画正方形线程程序

    本文将深入探讨如何通过实现`Runnable`接口和继承`Thread`类两种方式来创建线程,并实现在屏幕上随机画正方形的程序。 首先,让我们了解线程的概念。线程是程序中的单一顺序控制流,一个进程可以包含多个线程,它们...

Global site tag (gtag.js) - Google Analytics