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

进程(Process)线程(Thread)是程序运行的两个基本单元。Java并发编程更多的是和线程相关。

进程

进程是一个独立的执行单元,可将其视为一个程序或应用。然而,一个程序内部同事还包含多个进程。Java运行时环境就是一个单独的进程,在它内部还包含了作为进程的各种类和程序。

线程

可以将线程看做轻量级的进程。线程存在于进程当中,需要的资源开销较小。同一进程中的线程共享进程的资源。

Java多线程

每一个Java引用都只要有一个线程 - 主线程(main thread)。虽然后台还运行着许多其他的线程,如内存管理、系统管理、信号处理等等,但是从应用程序的角度来讲,main是第一个线程,我们可以从它开始创建多个线程。

线程的优点

1. 与进程相比,线程时轻量级的,创建线程的时间开销和资源开销都很小。

2. 同一进程的线程共享进程的数据和代码。

3. 线程间上下文切换的开销通常小于进程。

4. 与进程间通信相比,线程间通信更为方便。

在编程中,Java提供了两种创建线程的方式:

1. 实现java.lang.Runnable接口

2. 继承java.lang.Thread类

Java线程示例 - 实现Runnable接口

为了使类能运行,我们需要实现java.lang.Runnable接口,并在public void run()方法中提供实现。同时,还需要创建一个Thread对象,并将实现了Runnable接口的类作为参数闯入,这样才能调用start()在一个独立的线程中执行run()

下面就是一个实现了Runnable接口的Java类。

HeavyWorkRunnable.java

package com.journaldev.threads;

public class HeavyWorkRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("Doing heavy processing - START " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            //Get database connection, delete unused data from DB
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Doing heavy processing - END " + Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }
}

Java线程示例 - 继承Thread类

可以通过集成java.lang.Thread类并重写run()方法来创建自己的线程类。我们可以创建线程类的对象,并调用start()方法来执行定义好的run方法。

下面的例子演示了如何集成Thread类。

MyThread.java

package com.journaldev.threads;

public class MyThread extends Thread {

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println("Doing heavy processing - START " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            //Get database connection, delete unused data from DB
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Doing heavy processing - END " + Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }
}

下面的测试程序演示了如何创建并执行线程。

ThreadRunExample.java

package com.journaldev.threads;

public class ThreadRunExample {

    public static void main(String[] args) {
        Thread t1 = new Thread(new HeavyWorkRunnable(), "t1");
        Thread t2 = new Thread(new HeavyWorkRunnable(), "t2");
        System.out.println("Starting Runnable threads");
        t1.start();
        t2.start();
        System.out.println("Runnable Threads has been started");
        Thread t3 = new MyThread("t3");
        Thread t4 = new MyThread("t4");
        System.out.println("Starting MyThreads");
        t3.start();
        t4.start();
        System.out.println("MyThreads has been started"):
    }
}

上面的Java程序输出结果如下:

Starting Runnable threads
Runnable Threads has been started
Doing heavy processing - START t1
Doing heavy processing - START t2
Starting MyThreads
MyThread - START Thread-0
MyThreads has been started
MyThread - START Thread-1
Doing heavy processing - END t2
MyThread - END Thread-1
MyThread - END Thread-0
Doing heavy processing - END t1

一旦我们启动线程,它的执行就依赖于操作系统的时间分片,我们无法控制线程的执行。然而,我们却可以设置线程的优先级,但这无法保证高优先级的线程将会优先执行。

比较Runnable和Thread

如果你的类不仅仅作为一个线程来运行,而是需要提供更多的功能,那么,你就应该实现Runnable接口。如果你的类的目标仅仅只是作为线程来运行,你可以直接继承Thread类。

相比继承Thread类,实现Runnable接口更好一些,因为Java支持多接口实现。一旦你的类继承了Thread类,那它就无法再继承其他类了。

技巧:你可能注意到了,线程并不返回任何值,但如果我们希望线程在完成处理工作后能返回处理结果给客户程序的话,可以参考文章《Java Callable Future》

更新:从Java 8开始,Runnable议程诚意一个功能性接口,我们可以使用lambda表达式来实现它,而非使用匿名类。详情请见《Java 8 Lambda Expressions Tutorial》

原文地址:Java Thread Example - Extending Thread Class and Implementing Runnable Interface

Java线程示例 - 继承Thread类和实现Runnable接口,布布扣,bubuko.com

时间: 2024-10-23 10:39:03

Java线程示例 - 继承Thread类和实现Runnable接口的相关文章

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

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

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

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

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

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 v

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

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

多线程_创建线程_继承Thread类

public class ThreadDemo {   public static void main(String[] args){         Demo d = new Demo();   d.start();      for(int i = 0;i < 100;i++){      System.out.println("MainThread" + i);   }   } } class Demo extends Thread {   public void run(

Java线程状态及Thread类中的主要方法

要想实现多线程,就必须在主线程中创建新的线程对象. 任何线程一般具有5种状态,即创建,就绪,运行,阻塞,终止. 创建状态: 在程序中用构造方法创建了一个线程对象后,新的线程对象便处于新建状态,此时,他已经有了相应的内存空间和其他资源,但还处于不可运行状态. 就绪状态: 新建线程对象后,调用该线程的start()方法可以启动线程.当线程启动时,线程进入就绪状态.此时,线程将进入线程队列排队,等待CPU服务,这表明它已经具备了运行条件.-------(运行start()方法只是进入就绪状态,并没有开