进程（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