Java通过继承thread类与实现Runnable接口实现多线程的区别

Java中线程的创建有两种方式:

1.  通过继承Thread类,重写Thread的run()方法,将线程运行的逻辑放在其中

2.  通过实现Runnable接口,实例化Thread类

一、通过继承Thread类实现多线程

class MyThread extends Thread{
	String name = null;
	int ticket = 0;
	public MyThread(String name){
		this.name = name;
	}
	public synchronized void run(){
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName()+this.name+" ticket:"+ticket++);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}
}

通过如下方式运行:

1     public static void main(String[] args) {
2
3         MyThread mThread1 = new MyThread("线程一");
4         MyThread mThread2 = new MyThread("线程二");
5         MyThread mThread3 = new MyThread("线程三");
6         mThread1.start();
7         mThread2.start();
8         mThread3.start();
9     }    

运行结果如下:

 1 Thread-1线程二 ticket:0
 2 Thread-0线程一 ticket:0
 3 Thread-2线程三 ticket:0
 4 Thread-1线程二 ticket:1
 5 Thread-0线程一 ticket:1
 6 Thread-2线程三 ticket:1
 7 Thread-1线程二 ticket:2
 8 Thread-2线程三 ticket:2
 9 Thread-0线程一 ticket:2
10 Thread-1线程二 ticket:3
11 Thread-2线程三 ticket:3
12 Thread-0线程一 ticket:3
13 Thread-1线程二 ticket:4
14 Thread-2线程三 ticket:4
15 Thread-0线程一 ticket:4

二、通过继承Runnable接口实现多线程

多线程类:

 1 class RunThread implements Runnable{
 2
 3     int Counter = 0;
 4     @Override
 5     public synchronized void run() {
 6         for(int i=0;i<5;i++){
 7             System.out.println(Thread.currentThread().getName()+"count:"+Counter++);
 8             try {
 9                 Thread.sleep(100);
10             } catch (InterruptedException e) {
11                 // TODO Auto-generated catch block
12                 e.printStackTrace();
13             }
14         }
15     }
16 }

实现方式:

 1     public static void main(String[] args) {
 2
 3         RunThread rThread = new RunThread();
 4         Thread t1 = new Thread(rThread,"线程一");
 5         Thread t2 = new Thread(rThread,"线程二");
 6         Thread t3 = new Thread(rThread,"线程三");
 7         t1.start();
 8         t2.start();
 9         t3.start();
10   }

输出结果:

 1 线程一count:0
 2 线程一count:1
 3 线程一count:2
 4 线程一count:3
 5 线程一count:4
 6 线程二count:5
 7 线程二count:6
 8 线程二count:7
 9 线程二count:8
10 线程二count:9
11 线程三count:10
12 线程三count:11
13 线程三count:12
14 线程三count:13
15 线程三count:14

  

时间: 2024-08-06 15:57:28

Java通过继承thread类与实现Runnable接口实现多线程的区别的相关文章

Java中继承thread类与实现Runnable接口的区别

Java中线程的创建有两种方式: 1.  通过继承Thread类,重写Thread的run()方法,将线程运行的逻辑放在其中 2.  通过实现Runnable接口,实例化Thread类 在实际应用中,我们经常用到多线程,如车站的售票系统,车站的各个售票口相当于各个线程.当我们做这个系统的时候可能会想到两种方式来实现,继承Thread类或实现Runnable接口,现在看一下这两种方式实现的两种结果. Java代码   package com.threadtest; class MyThread e

Java基础知识强化之多线程笔记05:Java中继承thread类 与 实现Runnable接口的区别

1. Java中线程的创建有两种方式:  (1)通过继承Thread类,重写Thread的run()方法,将线程运行的逻辑放在其中. (2)通过实现Runnable接口,实例化Thread类. 2. 在实际应用中,我们经常用到多线程,如车站的售票系统,车站的各个售票口相当于各个线程.当我们做这个系统的时候可能会想到两种方式来实现,继承Thread类或实现Runnable接口,现在看一下这两种方式实现的两种结果. 继承thread类 1 package com.threadtest; 2 clas

Java中实现多线程继承Thread类与实现Runnable接口的区别

Java中线程的创建有两种方式: 1.  通过继承Thread类,重写Thread的run()方法,将线程运行的逻辑放在其中 2.  通过实现Runnable接口,实例化Thread类 在实际应用中,我们经常用到多线程,如车站的售票系统,车站的各个售票窗口相当于各个线程.当我们做这个系统的时候可能会想到两种方式来实现,继承Thread类或实现Runnable接口,现在看一下这两种方式实现的两种结果. 一:继承Thread类的方式 Java代码 package com.threadtest; cl

Java线程示例 - 继承Thread类和实现Runnable接口

进程(Process)和线程(Thread)是程序运行的两个基本单元.Java并发编程更多的是和线程相关. 进程 进程是一个独立的执行单元,可将其视为一个程序或应用.然而,一个程序内部同事还包含多个进程.Java运行时环境就是一个单独的进程,在它内部还包含了作为进程的各种类和程序. 线程 可以将线程看做轻量级的进程.线程存在于进程当中,需要的资源开销较小.同一进程中的线程共享进程的资源. Java多线程 每一个Java引用都只要有一个线程 - 主线程(main thread).虽然后台还运行着许

Java线程演示样例 - 继承Thread类和实现Runnable接口

进程(Process)和线程(Thread)是程序执行的两个基本单元. Java并发编程很多其它的是和线程相关. 进程 进程是一个独立的执行单元,可将其视为一个程序或应用.然而,一个程序内部同事还包括多个进程. Java执行时环境就是一个单独的进程,在它内部还包括了作为进程的各种类和程序. 线程 能够将线程看做轻量级的进程. 线程存在于进程其中,须要的资源开销较小.同一进程中的线程共享进程的资源. Java多线程 每个Java引用都仅仅要有一个线程 - 主线程(main thread).尽管后台

实现多线程的两种方法:继承Thread类或实现Runnable接口

实现多线程的两种方法:继承Thread类或实现Runnable接口 Java中实现多线程有两种方法:继承Thread类和实现Runnable接口,在程序开发中只要是多线程,我们一般都是实现Runnable接口,原因归结为一点:实现接口比继承类要好. 多线程的第一种实现方式:继承Thread类 步骤如下 创建一个继承Thread的类(假定为A),并重写Thread的run方法 构造一个A类对象,假定为aa 调用aa的start方法.(start方法是从Thread继承过来的) 具体例子如下 pac

【多线程学习记录一(2)】继承Thread类和实现Runnable接口、Callable接口的区别

1)Runnable和Callable同是接口 * Callable的任务执行后可返回值,而Runnable的任务是不能返回值(是void);call方法可以抛出异常,run方法不可以 * 运行Callable任务可以拿到一个Future对象,表示异步计算的结果.它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果.通过Future对象可以了解任务执行情况,可取消任务的执行,还可获取执行结果. * 加入线程池运行,Runnable使用ExecutorService的execute方

java中利用继承类和Runnable接口实现多线程的区别

利用继承Thread类实现的多线程无法资源共享 如下程序 class MyThread extends Thread{ public MyThread(String name){ super(); this.name=name; } public void run(){ while(tickets==0?false:true) { tickets--; System.out.println(name+" just selt one ticket,only "+tickets+"

Java 并发:Thread 类深度解析

摘要: Java 中 Thread类 的各种操作与线程的生命周期密不可分,了解线程的生命周期有助于对Thread类中的各方法的理解.一般来说,线程从最初的创建到最终的消亡,要经历创建.就绪.运行.阻塞 和 消亡 五个状态.在线程的生命周期中,上下文切换通过存储和恢复CPU状态使得其能够从中断点恢复执行.结合 线程生命周期,本文最后详细介绍了 Thread 各常用 API. 一. 线程的生命周期 Java 中 Thread类 的具体操作与线程的生命周期密不可分,了解线程的生命周期有助于对Threa