- 浏览: 349335 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
haoxinren:
: 不错 果然是hibernate 对数据库字段的问 ...
hibernate异常之表的映射 -
du_bo:
[b][/b]真的非常强大。。。多谢分享
牛B的js 时间控件(年月日时分秒) -
hd7139:
真的很强大,不错
牛B的js 时间控件(年月日时分秒) -
woguanqihu:
是啊大哥啊,给个图片多好啊
牛B的js 时间控件(年月日时分秒) -
kelenok:
火狐里貌似不显示控件
牛B的js 时间控件(年月日时分秒)
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演示了怎样在方法的内部创建线程。要运行线程的时候就调用方法,线程启动之后方法就返回。如果这个线程不那么重要,只是做一些辅助操作的话,那么相比在构造函数里启动线程,这个方法或许会更好一些
//: 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演示了怎样在方法的内部创建线程。要运行线程的时候就调用方法,线程启动之后方法就返回。如果这个线程不那么重要,只是做一些辅助操作的话,那么相比在构造函数里启动线程,这个方法或许会更好一些
发表评论
-
Java类的完整构造执行顺序(转)
2012-02-22 14:02 1103转自:http://hi.baidu.com/zh ... -
Class.forName( )你搞懂了吗?——转
2012-02-22 12:16 1040终于明白为什么加载 ... -
我常去的编程技术网站
2010-11-03 20:16 1353[序言] 其实大家都可以成为一个厉害的软件开发人员,希望大家通 ... -
java验证日期格式
2010-08-02 20:33 3472写道验证日期格式是否正确 @SuppressWarning ... -
实现JavaBeans到XML的相互转换
2009-10-19 18:21 885不用复杂的代码,就可以让您的JavaBeans自己控制到XML ... -
java进行数据加密
2009-06-23 18:01 3226本文主要谈一下密码学中的加密和数字签名,以及其在java中如何 ... -
DWRUtil未定义解决
2009-05-22 16:11 1917转自:http://www.iteye.com/topic/3 ... -
java面试宝典1
2009-05-22 11:34 1082java面试宝典 2009-04-06 19 ... -
java:comp/env
2009-04-29 15:21 3104try{ Context ctx=(Conte ... -
javamail pop3 原理
2009-04-27 15:53 1837在日常的生活中,书信往来是我们日常生活中不可缺少的一个环节。随 ... -
Tomcat中文手册
2009-04-27 13:44 1611本文档提供关于Tomcat的 ... -
apache james 使用手册
2009-04-22 17:12 1839一、简介 Apache James(Java Apache ... -
JMail 异常: java.lang.NoClassDefFoundError: javax/ac
2009-04-22 11:36 1891今天开发邮件系统,发送程序能在main函数中顺利运行.可是布署 ... -
getResourceAsStream()读取取资源文件的探讨
2009-04-21 16:10 8159首先是this.getClass().getClassLoad ... -
java中进行二进制,八进制,十六进制,十进制间进行相互转换
2009-03-08 22:24 1663十进制转成十六进制:Integer.toHexString(i ... -
Class.forName()与new 的区别
2008-09-18 13:50 1422Class.forName(xxx.xx.xx) 返回的是一个 ... -
java 科学记数法数转为其他数值类型
2008-06-11 11:30 3475在实际用运中,经常遇到要把科学计数的数值转为其他类型的数值,比 ... -
java Date学习总结
2008-05-27 10:34 11811.计算某一月份的最大天数Calendar time=Cale ... -
XP系统如何配置JAVA环境变量
2008-05-14 11:40 3178点击我的电脑然后按右键——属性——高级——环境变量——新建—— ... -
java中的字节流和字符流的存储比较
2008-04-22 18:12 2428引用:http://wuliguo.blog.51ct ...
相关推荐
Thread 线程类是 Java 中 Thread 和 Runnable 接口的实现,它提供了线程的基本操作和管理。下面是对 Thread 类的详细介绍: 1. Runnable 接口 Runnable 接口是 Thread 类的基类,它提供了 run() 方法,该方法是...
### 多线程的Runnable与Thread的区别 在Java中实现多线程有两种主要方式:一种是继承`Thread`类;另一种是实现`Runnable`接口。本文将深入探讨这两种方法的区别,帮助初学者更好地理解并选择适合场景的多线程实现...
在 Java 中,实现多线程有两种方法:继承 Thread 类和实现 Runnable 接口。在本文中,我们将对这两种方法进行详细的介绍和对比。 继承 Thread 类 继承 Thread 类是 Java 中最基本的多线程实现方法。 Thread 类提供...
Java提供了两种创建线程的方式:继承Thread类和实现Runnable接口。 1. 继承Thread类创建线程: 当你选择继承Thread类时,你需要创建一个新的类,这个类扩展自Thread类。Thread类已经实现了Runnable接口,所以你不...
有两种主要的方式可以实现多线程:继承`Thread`类和实现`Runnable`接口。这两种方法各有特点,适用于不同的场景。 **继承Thread类** 当一个类直接继承自`Thread`类时,这个类本身就成为一个线程实体。你可以重写`...
本篇文章将深入探讨如何利用`Thread`类和`Runnable`接口来实现阶乘计算的多线程解决方案。阶乘计算是数学中的一个概念,对于非负整数n,其阶乘表示为所有小于等于n的正整数的乘积,记作n!。 首先,我们来看如何使用...
Thread 和 Runnable 是实现 Java 多线程的两种方式,Runnable 是接口,Thread 是类,建议使用 Runnable 实现 Java 多线程,不管如何,最终都需要通过 thread.start() 来使线程处于可运行状态。 Thread 的 start 和 ...
在Java中创建线程有两种方法:使用Thread类和使用Runnable接口。在使用Runnable接口时需要建立一个Thread实例。因此,无论是通过Thread类还是Runnable接口建立线程,都必须建立Thread类或它的子类的实例。
Java中Thread和Runnable是两个不同的概念,它们都是Java中的线程机制,但是它们之间有着本质的区别。 Thread是Java中的一个类,而Runnable是一个接口。Thread类实现了Runnable接口,Runnable接口只有一个run()方法,...
### Java多线程技术详解 #### 一、引言 多线程编程是现代软件开发中不可或缺的一部分,尤其是在Java这样的面向对象编程语言中尤为...同时,合理地处理线程间的同步和避免死锁也是构建稳定、可靠的多线程应用的关键。
在Java编程语言中,多线程的实现有多种方式,其中最常见的是通过继承`Thread`类和实现`Runnable`接口。这两种方法各有其特点和适用场景,理解它们之间的区别对于编写高效、可维护的多线程应用至关重要。 ### 继承...
在Java编程语言中,创建线程有两种主要方式:继承`Thread`类和实现`Runnable`接口。由于Java的单继承特性,当一个类需要继承其他类时,就不能再直接继承`Thread`,这时实现`Runnable`接口就成为创建线程的优选方案。...
在Java中,实现多线程的两种主要方式分别是:**通过继承`Thread`类** 和 **实现`Runnable`接口**。下面将详细介绍这两种方式,并提供相应的示例程序。 #### 一、通过继承`Thread`类实现多线程 在Java中,可以通过...
`Runnable`接口是Java实现多线程的一种方式,通过实现`Runnable`接口并创建`Thread`对象,可以轻松地创建并运行多线程。`TestRunnable.java`文件展示了这一过程,同时也提醒我们在实际开发中要注意线程同步和通信,...
在一个线程中求100以内的偶数,求出一个偶数后休眠一个随机时间在(1-300毫秒之间).在另一个线程中求奇数,求出一个奇数后也休眠一个随机时间(1-300毫秒之间).输出数据时应有提示,指明是哪个线程输出的数据 用实例...
在第二种方法中,由于3个Thread对象共同执行一个Runnable对象中的代码,因此可能会造成线程的不安全,比如可能ticket会输出-1(如果我们Syste
1. 写两个线程,一个线程打印1-52,另一个线程打印字母A-Z。打印顺序为12A34B56C……5152Z。 学习线程之间的通信协调关系。 2. 使用 runnable 接口实现按两... 使用继承Thread类方式和实现Runnable接口两种方式实现。
本篇将基于`Runnable`接口提供一个简单的多线程下载示例,帮助开发者理解如何在Android中实现这一功能。 首先,我们要明白在Android中,主线程(UI线程)负责处理用户交互和更新界面,因此,长时间的网络请求或计算...
本文将深入探讨如何通过实现`Runnable`接口和继承`Thread`类两种方式来创建线程,并实现在屏幕上随机画正方形的程序。 首先,让我们了解线程的概念。线程是程序中的单一顺序控制流,一个进程可以包含多个线程,它们...