基于Runnable接口实现多线程

虽然可以通过Thread类的继承来实现多线程的定义，但是在Java程序里面对于继承永远是存在单继承局限的，所以在Java里面又提供有第二种多线程的主体定义结构形式，实现java.lang.Runnable接口，此接口定义如下：

public Interface Runnable{
    public void run();
}

范例：通过Runnable实现多线程的主体类

class MyThread implements Runnable{//线程的主体类
	private String title;
	public MyThread(String title) {
		this.title = title;
	}
	@Override
	public void run() {
		for(int x = 0;x < 10;x++) {
			System.out.println(this.title + "运行，x = " + x); 
		}
	}
}

但是此时由于不再继承Thread父类了，那么对于此时的MyThread类中也不就不再支持有start()方法了，如果不使用start方法是无法进行多线程启动的，那么这个时候就需要观察一下Thread类所提供的构造方法了。

构造方法：public Thread(Runnable target)；

package cn.mldn.demo;

public class ThreadDemo {
	public static void main(String[] args) {
		Thread threadA = new Thread(new MyThread("多线程A"));	//通过Thread类的构造方法传入Runnable对象
		Thread threadB = new Thread(new MyThread("多线程B"));
		Thread threadC = new Thread(new MyThread("多线程C"));
		threadA.start();//启动多线程
		threadB.start();
		threadC.start();
	}
}

class MyThread implements Runnable{//线程的主体类
	private String title;
	public MyThread(String title) {
		this.title = title;
	}
	@Override
	public void run() {
		for(int x = 0;x < 10;x++) {
			System.out.println(this.title + "运行，x = " + x); 
		}
	}
}

 结果：

多线程C运行，x = 0
多线程A运行，x = 0
多线程B运行，x = 0
多线程A运行，x = 1
多线程C运行，x = 1
多线程A运行，x = 2
多线程B运行，x = 1
多线程B运行，x = 2
多线程B运行，x = 3
多线程B运行，x = 4
多线程B运行，x = 5
多线程B运行，x = 6
多线程B运行，x = 7
多线程B运行，x = 8
多线程B运行，x = 9
多线程A运行，x = 3
多线程A运行，x = 4
多线程A运行，x = 5
多线程A运行，x = 6
多线程A运行，x = 7
多线程A运行，x = 8
多线程A运行，x = 9
多线程C运行，x = 2
多线程C运行，x = 3
多线程C运行，x = 4
多线程C运行，x = 5
多线程C运行，x = 6
多线程C运行，x = 7
多线程C运行，x = 8
多线程C运行，x = 9

这个时候的多线程实现，由于只是实现了Runnable的接口对象，所以此时线程主体类上不再有单继承的局限，这样的设计才是一个标注性的设计。

可以发现从JDK1.8开始，Runnable接口使用了函数式接口的定义，所以也可以利用Lambda表达式进行线程类实现。

范例：利用Lambda实现定义

package cn.mldn.demo;

public class ThreadDemo {
	public static void main(String[] args) {
		for(int x = 0;x < 3;x++) {
			String title = "线程对象-"+x;
			
			new Thread(()->{	//新建一个Thread对象构造方法直接填写Lambda表达式
				for(int y = 0;y < 10;y++) {
					System.out.println(title + "运行，y = " + y); 
				}
			}).start();
		}
	}
}

结果：

线程对象-0运行，y = 0
线程对象-1运行，y = 0
线程对象-1运行，y = 1
线程对象-1运行，y = 2
线程对象-2运行，y = 0
线程对象-1运行，y = 3
线程对象-2运行，y = 1
线程对象-1运行，y = 4
线程对象-1运行，y = 5
线程对象-1运行，y = 6
线程对象-1运行，y = 7
线程对象-1运行，y = 8
线程对象-1运行，y = 9
线程对象-2运行，y = 2
线程对象-2运行，y = 3
线程对象-2运行，y = 4
线程对象-2运行，y = 5
线程对象-2运行，y = 6
线程对象-2运行，y = 7
线程对象-2运行，y = 8
线程对象-2运行，y = 9
线程对象-0运行，y = 1
线程对象-0运行，y = 2
线程对象-0运行，y = 3
线程对象-0运行，y = 4
线程对象-0运行，y = 5
线程对象-0运行，y = 6
线程对象-0运行，y = 7
线程对象-0运行，y = 8
线程对象-0运行，y = 9

在以后的开发之中优先考虑的就是Runnable接口实现，并且永恒都是通过Thread类对象启动线程。