在Java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口。
Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了,但是一个类只能继承一个父类,这是此方法的局限。
①使用Thread方式启动多线程:
class MyThread extends Thread{
private String name;
public MyThread(String name) {
super();
this.name = name;
}
public void run(){
for(int i=0;i<10;i++){
System.out.println("线程开始:"+this.name+",i="+i);
}
}
}
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread("线程a");
MyThread mt2=new MyThread("线程b");
mt1.run();
mt2.run();
}
}
运行结果:
Thread Run:Thread A,i=0
Thread Run:Thread A,i=1
Thread Run:Thread A,i=2
Thread Run:Thread A,i=3
Thread Run:Thread A,i=4
Thread Run:Thread B,i=0
Thread Run:Thread B,i=1
Thread Run:Thread B,i=2
Thread Run:Thread B,i=3
Thread Run:Thread B,i=4
不过此时运行的结果并不是我们所预料中的那样,而是先执行完线程A,然后再执行线程B。导致这样的结果是因为程序中使用了run方法启动线程,通过查找源代码:
public void run() {
if (target != null) {
target.run();
}
}
因为线程是跟操作系统相关的,run方法并没有操作系统相关的操作,所以也就不会产生多线程的结果啦。通过查看jdk文档可以发现start方法:当调用start方法时,JVM会调用run方法。下面使用start方法启动线程:
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread("Thread A");
MyThread mt2=new MyThread("Thread B");
//mt1.run();
//mt2.run();
mt1.start() ;
mt2.start() ;
}
}
运行结果:
Thread Run:Thread A,i=0
Thread Run:Thread A,i=1
Thread Run:Thread B,i=0
Thread Run:Thread B,i=1
Thread Run:Thread B,i=2
Thread Run:Thread B,i=3
Thread Run:Thread A,i=2
Thread Run:Thread A,i=3
Thread Run:Thread A,i=4
Thread Run:Thread B,i=4
可以看到此时线程A和线程B就并行执行了。
②通过实现Runnable接口实现多线程
因为在Java中一个class只能继承一个父类,所以在实际开发中很少有使用到Thread,而是使用Runnable接口。
class MyThread02 implements Runnable{
private String name;
public MyThread02(String name) {
this.name = name;
}
public void run(){
for(int i=0;i<100;i++){
System.out.println("Thread Run:"+this.name+",i="+i);
}
}
}
public class ThreadDemo02 {
public static void main(String[] args) {
MyThread mt1=new MyThread("Thread A");
MyThread mt2=new MyThread("Thread B");
new Thread(mt1).start() ;
new Thread(mt2).start() ;
}
}
运行结果:
Thread Run:Thread B,i=0
Thread Run:Thread B,i=1
Thread Run:Thread A,i=0
Thread Run:Thread B,i=2
Thread Run:Thread A,i=1
Thread Run:Thread B,i=3
Thread Run:Thread A,i=2
Thread Run:Thread A,i=3
Thread Run:Thread B,i=4
Thread Run:Thread A,i=4
两种实现方式的区别:
Thread方式:
- 通过继承Thread类
- 重写run方法
- 在main函数中通过new Thread子类,然后调用start方法开启多线程
Runnable方式:
- 通过实现接口Runnable
- 重写run方法
- 在main函数中通过new Thread传入Runnable对象,然后调用start方法开启多线程
在程序开发中只要是多线程肯定永远以实现Runnable接口为主,因为实现Runnable接口相比继承Thread类有如下好处:
- 避免单继承的局限,一个类可以继承多个接口。
- 适合于资源的共享
实例(以卖票程序为例Thread方式实现,系统中有5张票,每个线程相当于一个售票机):
public class MyThread03 extends Thread{
private String name ;
private int ticket=5;
public MyThread03(String name){
this.name = name ;
}
public void run(){
for(int i=0;i<20;i++){
if(this.ticket>0){
System.out.println(name+"卖票,剩余:"+this.ticket--);
}
}
}
}
public class ThreadTicket {
public static void main(String[] args) {
Thread mt1=new MyThread03("Thread A");
Thread mt2=new MyThread03("Thread B");
Thread mt3=new MyThread03("Thread C");
mt1.start();
mt2.start();
mt3.start();
}
}
运行结果:
Thread A卖票,剩余:5
Thread C卖票,剩余:5
Thread B卖票,剩余:5
Thread C卖票,剩余:4
Thread A卖票,剩余:4
Thread C卖票,剩余:3
Thread B卖票,剩余:4
Thread C卖票,剩余:2
Thread A卖票,剩余:3
Thread A卖票,剩余:2
Thread C卖票,剩余:1
Thread B卖票,剩余:3
Thread A卖票,剩余:1
Thread B卖票,剩余:2
Thread B卖票,剩余:1
从运行结果可以看出,此时三个售票机并没有共享5张票,而是各自买了5张票,这是不合理的。
实例(Runnable接口方式):
public class MyThread04 implements Runnable{
private int ticket=5;
public void run(){
for(int i=0;i<20;i++){
if(this.ticket>0){
System.out.println(Thread.currentThread().getName() +"卖票,剩余:"+this.ticket--);
}
}
}
}
public class ThreadTicket02 {
public static void main(String[] args) {
Runnable rn=new MyThread04();
new Thread(rn,"Thread A").start();
new Thread(rn,"Thread B").start();
new Thread(rn,"Thread C").start();
}
}
运行结果:
Thread A卖票,剩余:5
Thread A卖票,剩余:2
Thread C卖票,剩余:3
Thread B卖票,剩余:4
Thread A卖票,剩余:1
此时使用Runnable方法向三个Thread中传递同一个对象,即可实现资源的共享。当然此时剩余票数并没有顺序,因为此时并没有对程序进行同步处理,可在run方法中添加synchronized同步声明:
public class MyThread04 implements Runnable{
private int ticket=5;
public synchronized void run(){
for(int i=0;i<20;i++){
if(this.ticket>0){
System.out.println(Thread.currentThread().getName() +"卖票,剩余:"+this.ticket--);
}
}
}
}
运行结果:
Thread B卖票,剩余:5
Thread B卖票,剩余:4
Thread B卖票,剩余:3
Thread B卖票,剩余:2
Thread B卖票,剩余:1
最后通过查看源代码可知道其实Thread已经实现了Runnable接口:class Thred implements Runnable。
这是自己第一篇博客,语言组织方面没有那么完善,同时博客内容中有不少是从别的地方借鉴的,希望能够培养自己以后写博客的习惯,同时也能提高自己的能力。
分享到:
相关推荐
Java中Runnable和Thread的区别分析.rar
在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口;Thread类是在java.lang包中定义的。接下来通过本文给大家浅析Java中Runnable和Thread的区别,一起看看吧
在Java中创建线程有两种方法:使用Thread类和使用Runnable接口。在使用Runnable接口时需要建立一个Thread实例。因此,无论是通过Thread类还是Runnable接口建立线程,都必须建立Thread类或它的子类的实例。
在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口,下面就拉分别介绍一下这两种方法的优缺点
主要介绍了Java中Thread 和Runnable的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
RunnableThread1.java
主要介绍了Java中继承thread类与实现Runnable接口的比较的相关资料,需要的朋友可以参考下
1、Java有两种实现多线程的方式:通过Runnable接口、通过Thread直接实现,请掌握这两种实现方式,并编写示例程序。 2、多线程是并发执行的,交替占有cpu执行,请编写示例程序,并观察输出结果。 3、采用线程同步方法...
分别用Thread类和Runnable接口实现的阶乘的计算过程及结果的显示(本来一开始设置的不要积分,不知道为啥变得需要积分了,故此调整一下)
1. 什么是Runnable接口: 1.1 介绍Runnable接口 1.2 与Thread类的对比 2. 创建线程的方式: 2.1 继承Thread类 2.2 实现Runnable接口 3. 实现Runnable接口: 3.1 实现步骤 3.2 优点与用途 4. 启动线程: 4.1 使用...
主要介绍了java 多线程Thread与runnable的区别的相关资料,java线程有两种方法继承thread类与实现runnable接口,下面就提供实例帮助大家理解,需要的朋友可以参考下
5. Thread 类中的 start () 和 run () 方法有什么区别? 6. Java 中 Runnable 和 Callable 有什么不同? 7. Java 中 CyclicBarrier 和 CountDownLatch 有什么不同? 8. Java 内存模型是什么? 9. Java 中的 volatile...
Java中Runnable和Callable的区别 Runnable和Callable都代表要线程中执行的任务。Runnable是JDK1.0加入的,而Callable确实是在JDK1.5加入的。 区别:Callable的 call() 方法可以返回值和抛出异常, 而Runnable的...
主要介绍了Java 线程(Thread,Runnable,Callable)实例详解的相关资料,这里对java 线程的三种方法进行了对比,需要的朋友可以参考下
java中实现多线程有两种方法:一种是继承Thread类,另一种是实现Runnable接口。
1. 写两个线程,一个线程打印1-52,另一个线程打印字母A-Z。打印顺序为12A34B56C……5152Z。 学习线程之间的通信协调关系。 2. 使用 runnable 接口实现按两... 使用继承Thread类方式和实现Runnable接口两种方式实现。
主要介绍了java Runnable接口创建线程的相关资料,需要的朋友可以参考下
在Java中创建线程有两种方法:使用Thread类和使用Runnable接口。 要注意的是Thread类也实现了Runnable接口,因此,从Thread类继承的类的实例也可以作为target传入这个构造方法。可通过这种方法实现多个线程的...