进程（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"):
    }
}

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

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

原文：http://blog.csdn.net/snarlfuture/article/details/26517953