线程的三种实现方式

Java中线程的实现有三种方式，分别是继承Thread类、实现Runnable接口和实现Callable接口。

继承Thread类

Thread类是Java.lang包中的一个类，从这个类中实例化的对象代表线程，程序员启动一个新的线程需要建立Thread类的实例。

Thread类中两个常用的构造方法是：

public Thread()//创建一个新的线程对象
Public Thread(String threadName)//创建一个名称为threadName的线程对象

当一个类继承Thread类后，需要在该类中覆盖run()方法，将完成线程真正功能的代码写入run()方法中，然后调用Thread类中的start()方法启动线程。

例如：

class MyThread extends Thread {
	@Override
	public void run() {
		for (int i = 0;i < 20;i++) {
			System.out.println("一边听歌");
		}
	}
}

测试代码：

public class Test {
	public static void main(String[] args) {
		MyThread myThread = new MyThread();//创建实例
		myThread.start();//启动线程
		
		for (int i = 0;i < 20;i++) {
			System.out.println("一边敲代码");
		}
	}
}

运行结果：

在mian()方法中，启动线程需要调用Thread类中的start()方法，start()方法调用被覆盖的run()方法，如果不调用start()方法，线程永远都不会启动，在没有调用start()方法之前，Thread对象只是一个实例，而不是一个真正的线程。

从运行结果中可以看到，调用start()方法后并不是立即执行多线程代码，而是使得该线程变为可运行状态，什么时候调度运行由操作系统决定的。

注意：如果不start()方法启动线程，直接调用run()方法，不是多线程而只是一个简单的方法调用。

实现Runnable接口

通过一个类继承Thread类来实现一个线程具有单继承的局限性，该子类不能再继承其他类，为了解决单继承的局限性，推荐通过实现Runnable()接口来实现一个线程。

启动一个通过实现Runnable接口实现的线程也需要通过Thread类对象的start()方法，Thread类中还有另外两个构造方法：

public Thread(Runnable target);//通过一个Runnable类型的对象实例化一个Thread对象
public Thread(Runnable target,String name); //通过一个Runnable类型的对象实例化一个名称为name的Thread对象

使用Runnable()接口启动新线程的步骤如下：

（1）自定义类实现Runnable接口，并实现该接口的run()方法；

（2）用实现Runnable接口的对象作为参数实例化一个Thread对象；

（3）调用Thread类的start()方法。

例如：

class MyRunnable implements Runnable {
	@Override
	public void run() {
		for (int i = 0;i < 10;i++) {
			System.out.println("一边听歌");
		}
	}
}

测试代码：

public class Test {
	public static void main(String[] args) {
		new Thread(new MyRunnable()).start();
		for (int i = 0;i < 10;i++) {
			System.out.println("一边敲代码");
		}
	}
}

运行结果：

其实不管是通过继承Thread类还是通过实现Runable接口来实现线程，最终都是通过Thread类的对象的API来控制线程（代理设计模式）。

Thread类本质上也是实现了Runnable接口，启动线程的唯一方法就是通过Thread类的start()方法。start()方法是一个native（本地）方法，它将启动一个新线程，并执行run()方法（Thread类中提供的run()方法是一个空方法）。

注意：一个Native Method就是一个Java调用非Java代码的接口。我们把这类接口称为JNI（Java Native Interface），它提供了若干的API实现了Java和其他语言的通信（主要是C&C++），它允许Java代码和其他语言写的代码进行交互，这里主要是与操作系统交互。

实现Callable接口

我们还可以通过实现Callable接口，重写call()方法来实现一个线程。Callable接口是juc（java.util.concurrent）包下的一个泛型接口，只有一个call()方法。

Callable接口与Runnable接口的功能类似，但提供了比Runnable更强大的功能，主要表现为以下三点：

（1）Callable可以在任务结束后提供一个返回值，Runnable无法提供这个功能；

（2）Callable接口中的call()方法可以抛出异常，而Runnable的run()方法不能抛出异常，必须在run()捕获；

（3）运行Callable可以拿到一个Future对象，Future对象表示异步计算的结果，它提供了检查计算是否完成的方法。由于线程属于异步计算模型，因此无法从别的线程中得到函数的返回值，在这种情况下，就可以使用Future来监视目标线程调用call()方法的情况，当调用Future的get方法以获取结果时，当前线程就会阻塞，直到call()方法结束返回结果。

使用Callable接口实现线程的步骤如下：

（1）自定义类实现Callable接口，并实现该接口的call()方法；
（2）创建实现Callable接口的自定义类对象；
（3）创建执行服务；
（4）提交执行；
（5）获取结果；
（6）关闭服务。

例如：

class MyCallable implements Callable {

	private String str;
	
	public MyCallable(String str) {
		this.str = str;
	}
	
	@Override
	public 	Boolean call() throws Exception {
		for (int i = 0;i < 10;i++) {
			System.out.println("一边"+str);
		}
		return true;
	}
}

测试代码：

public class Test {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建目标对象
		MyCallable mc1 = new MyCallable("唱歌");
		MyCallable mc2 = new MyCallable("敲代码");
		//创建执行服务
		ExecutorService ser = Executors.newFixedThreadPool(2);
		//提交执行
		Future<Boolean> result1 = ser.submit(mc1);
		Future<Boolean> result2 = ser.submit(mc2);
		//获取结果
		boolean r1 = result1.get();
		boolean r2 = result2.get();
		//关闭服务
		ser.shutdownNow();
		
		System.out.println("线程1执行结果：" + r1);//打印结果
		System.out.println("线程2执行结果：" + r2);//打印结果
	}
}

运行结果：

简化线程实现

对于只使用一次并且逻辑较简单的线程，为了提升性能我们可以使用内部类的方式对它的表示进行简化，在jdk1.8版本后还可以使用lambda表达式进行简化。

注意：内部类只在外部类使用时才会加载，外部类不使用时不会加载，所以可以提升性能。

内部类实现简化：

public class Test {
	
	//静态内部类
	static class MyRunnable1 implements Runnable {
		@Override
		public void run() {
			System.out.println("静态内部类简化线程实现");
		}	
	}
	
	public static void main(String[] args) {
		new Thread(new MyRunnable1()).start();
		
		//局部内部类
		class MyRunnable2 implements Runnable {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("局部内部类简化线程实现");
			}
		}
		new Thread(new MyRunnable2()).start();
		
		//匿名内部类
		new Thread(new Runnable() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("匿名内部类简化线程实现");
			}
		}).start();
	}
}

运行结果：

Lambda表达式实现简化：

public class Test {
	public static void main(String[] args) {
		new Thread(() -> {
			System.out.println("Lambda表达式简化线程实现");
		}).start();
	}
}