进程（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类，那它就无法再继承其他类了。
技巧：你可能注意到了，线程并不返回任何值，但如果我们希望线程在完成处理工作