Java多线程实现

概述：

共有三种实现方法：（1）继承Thread类；（2）实现Runnable接口；（3）实现Callable接口(此方法为JDK1.5增加的方法)。
实际开发中主要使用接口定义的线程类，即方法（2）与方法（3）。

1、继承Thread类：

java.lang.Thread 是一个负责线程操作的类，任何类只需继承 Thread 类就能够成为一个线程的主类。主类必须有它的使用方法，线程启动的主方法需要覆写 Thread 类中的 run() 方法实现。线程主体类的定义格式如下：

class 类名称 extends Thread{
    属性...;
    方法...;
    
    @Override
    public void run(){
        线程的主体方法；
    }
}

所有的线程与进程都是通过轮流抢占资源实现对应程序部分的运行，因此多线程的执行应该是多个线程彼此交替执行。直接调用 run() 方法，并不能启动多线程，多线程启动的唯一方法是调用 Thread 中的 start() 方法：public void start()。

示例1：

//通过继承Thread类，实现一个多线程操作类
class MyThread extends Thread{  
	private String name;  // 类名称
	public MyThread(String name) {	// 定义构造方法
		this.name = name;
	}
	@Override
	public void run() {
		for(int i=0; i<100; i++) {
			System.out.println(this.name + "--" + i);
		}
	}
}

// 启动多线程
public class ThreadDemo {
	public static void main(String[] args) {
		// 实例化多线程对象
		MyThread thread1 = new MyThread("A线程");
		MyThread thread2 = new MyThread("B线程");
		MyThread thread3 = new MyThread("C线程");
		// 启动多线程
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

使用 Thread类 实现多线程存在一个缺点：单继承问题。

2、实现Runnable接口：

Runnable 接口定义：

 要启动多线程，必须通过 Thread类 中的 start() 方法。但是，因为 Runnable 接口没有提供可以被继承的 Start() 方法，所以需要其他途径实现。

Thread 类中提供了一个有参构造方法，如上图。本方法可以接收一个 Runnable 接口对象。示例如下：

// 定义线程主题类
class RunnableThread implements Runnable{
	private String name;
	public RunnableThread(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		for(int x=0; x<100; x++) {
			System.out.println(this.name + "--" + x);
		}
	}
}
// 利用 Thread 启动多线程 
public class RunnableDemo {
	public static void main(String[] args) {
		// 实例化多线程类对象
		RunnableThread run1 = new RunnableThread("A线程");
		RunnableThread run2 = new RunnableThread("B线程");
		RunnableThread run3 = new RunnableThread("C线程");
		// 利用Thread启动多线程
		new Thread(run1).start();   // 等价实现 Thread r1 = new Thread(run1); r1.start();
		new Thread(run2).start();
		new Thread(run3).start();
	}
}

其实，我们查看 Thread类 的源码可以发现，Thread类 实现了 Runnable 接口，即 Thread类 是Runnable 接口的子类：

对比： 

• 以上两种方式都需要一个线程的主类，这个类可以实现 Runnable 接口或者继承 Thread 类，无论使用哪种方式都需要在子类中覆写 run() 方法，此方法为线程的主方法；
• Thread类 是 Runnable接口 的子类，而使用 Runnable接口 可以避免单继承局限，并可以更加方便地体现现数据共享的概念。

三、实现Callable接口：

问题的引出：Runnable接口 里面的run() 方法不能返回操作结果。从 JDK1.5 开始，Java 提供了一个新的支持多线程实现的接口：java.util.concurrent.Callable，定义如下：

 新的问题的出现：

多线程的主体定义完成后，需要利用 Thread 类 启动多线程。但在 Thread  类中没有定义任何构造方法可以直接接收 Callable 接口对象实例，并且由于需要接收 Call() 方法返回值的问题，于是 从JDK1.5 开始，Java 同时提供了一个 java.util.concurrent.FutureTask<V> 类：

通过上图，可以看出 FutureTask类 实现了 RunnableFuture接口，而 RunnableFuture 接口又实现了 Future 与 Runnable 接口。故 FutureTask类 是 Runnable接口 的子类，因此其可以利用 Thread类 来实现多线程的启动。

FutureTask类常用方法：

FutureTask类常用方法

No	方法	类型	描述
1	public FutureTask(Callable<V> callable)	构造	接收Callable接口实例
2	public FutureTask(Runnable runnable, V result)	构造	接收Runnable接口实例，并制定返回值的类型
3	public V get() throws Interrupted Exception, ExecutionException	普通	取得线程操作结果，此方法为 Future接口 定义

可见，FutureTask类 可以接收 Callable接口 实例 ，如果想要接收返回结果，使用 get() 方法即可。

实现多线程代码示例：

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class CallableThread implements Callable<String>{
	private String name;
	private int tickets = 10;
	public CallableThread(String name) {
		this.name = name;
	}
	@Override
	public String call() throws Exception {
		for(int i=0; i<100; i++) {
			if(this.tickets > 0) {
				System.out.println(this.name + "剩余，tickets = " + this.tickets--);
			}
		}
		return "票已全部售出。";
	}
} 

public class CallableDemo {
	public static void main(String[] args) throws Exception{
		CallableThread thread1 = new CallableThread("thread1");  // 实例化多线程对象
		CallableThread thread2 = new CallableThread("thread2");  // 实例化多线程对象
		CallableThread thread3 = new CallableThread("thread3");  // 实例化多线程对象
		
		FutureTask<String> task1 =  new FutureTask<String>(thread1);
		FutureTask<String> task2 =  new FutureTask<String>(thread2);
		FutureTask<String> task3 =  new FutureTask<String>(thread3);
		// FutureTask 是 Runnable 接口的子类，所以可以使用Thread类的构造来接收 task 对象；
		new Thread(task1).start();
		new Thread(task2).start();
		new Thread(task3).start();
		// 依靠Futuretask的父类接口Future中的get() 方法实现
		System.out.println("线程1的返回结果"+task1.get());
		System.out.println("线程2的返回结果"+task2.get());
		System.out.println("线程3的返回结果"+task3.get());
	}
}