Java线程 一
- 1.继承Thread类实现多线程
- 2.Runable实现多线程
1.继承Thread类实现多线程
Java里面提供有一个java.lang.Thread的程序类，那么一个类只要继承了此类就表示这个类为线程的主体类，但是并不是说这个类就可以直接实现多线程处理了，因为还需要覆写Thread类中提供的一个run()方法，而这个方法就属于线程的主方法。
例如：
class MyThread extends Thread { //线程的主体类
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);
}
}
}多线程要执行的功能都应该在run()方法中进行定义。需要说明的是：在正常情况下，如果要想使用一个类中的方法，那么肯定要产生实例化对象，而后去调用类中提供的方法，但是run()方法是不能够被直接调用的，因为这里面牵扯到一个系统的资源调度问题，所以要想启动多线程必须使用Thread类中的start()方法完成。
例如：没有start()方法，直接使用run()方法
class MyThread extends Thread { //线程的主体类
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);
}
}
}
public class test {
public static void main(String[] args) {
new MyThread("线程A").run();
new MyThread("线程B").run();
new MyThread("线程C").run();
}
}结果如下：
线程A运行，x = 0
线程A运行，x = 1
线程A运行，x = 2
线程A运行，x = 3
线程A运行，x = 4
线程A运行，x = 5
线程A运行，x = 6
线程A运行，x = 7
线程A运行，x = 8
线程A运行，x = 9
线程B运行，x = 0
线程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
线程C运行，x = 0
线程C运行，x = 1
线程C运行，x = 2
线程C运行，x = 3
线程C运行，x = 4
线程C运行，x = 5
线程C运行，x = 6
线程C运行，x = 7
线程C运行，x = 8
线程C运行，x = 9从结果可以看出他是先执行完A，然后在执行B，依次往下，这样导致中间有很多的空间资源浪费，并且很明显类似单线程。
例如：有start()方法
class MyThread extends Thread { //线程的主体类
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);
}
}
}
public class test {
public static void main(String[] args) {
new MyThread("线程A").start();
new MyThread("线程B").start();
new MyThread("线程C").start();
}
}这里执行完结果发现是交替的。这才是多线程，并且通过此时的调用你可以发现，虽然调用了是start()方法，但是最终执行的是run()方法，并且所有的线程对象都是交替执行的。
疑问？为什么多线程的启动不直接使用run()方法而必须使用Thread类中的start()方法呢？
最好查看一下start()方法来了解一下。多注意start()方法和start0()的关系。
任何情况下，只要定义了多线程，多线程的启动永远只有一种方案：Thread类中的start()方法。
2.Runable实现多线程
虽然可以通过Thread类的继承来实现多线程的定义，但是在Java程序里面对于继承永远都是存在有单继承局限，所以在Java里面又提供有第二种多线程的主体定义结构形式：实现Java.lang.Runnable接口，此接口定义如下：
@FunctionalInterface //函数式接口，JDK必须是1.8版本之后
public interface Runnable{
public void run();
}实现接口如下：
class MyThread implements Runnable { //实现Runable 线程的主体类
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()这个继承的方法，可是如果不使用Thread.start()方法是无法进行多线程启动的，那么这个时候就需要去观察一下Thread类所提供的的构造方法。
这里Thread类的构造方法里面有：
public Thread(Runnable target)的方法可以自己找一下，ctrl + 点击Thread类。
例如：通过Runable和Thread来启动多线程
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);
}
}
}
public class test {
public static void main(String[] args) {
Thread thread1 = new Thread(new MyThread("线程对象1"));
Thread thread2 = new Thread(new MyThread("线程对象2"));
Thread thread3 = new Thread(new MyThread("线程对象3"));
thread1.start();
thread2.start();
thread3.start();
}
}运行后查看结果，你可以发现结果和之前单继承Thread的结果一样是交替运行，这里没有单继承的局限，没有继承Thread，而是调用的Thread构造函数通过Runnable来实现多线程的，这样的设计才是一个标准型设计。
因为Runnable接口使用的是函数式接口定义，所以也可以直接利用Lambda表达式来实现多线程定义：(这里对Lambda表达式不清楚的老铁，可以参考本博主Java(笔记)专栏下的Lambda表达式来了解学习一下，注意：这里Lambda表达式必须要是JDK1.8版本之后！！！！)
public class test {
public static void main(String[] args) {
for(int x=0;x<3;x++){
final String title = "线程对象-"+x;
Runnable run = ()->{ //Lambda表达式
for(int y=0;y<10;y++){
System.out.println(title+"运行。y="+y);
}
};
new Thread(run).start();
}
}
}可以查看到结果是一样的，此外还可以更加简洁一点，如下：
public class test {
public static void main(String[] args) {
for(int x=0;x<3;x++){
final String title = "线程对象-"+x;
new Thread(()->{
for(int y=0;y<10;y++){
System.out.println(title+"运行。y="+y);
}
}).start();
}
}
}注意：这里如果是eclipse，可能会显示错误红曲线，没关系，关闭项目，再打开就可以了，也可以直接运行，这个是没有报错的，这可能是个bug，不太清楚。
在开发之中，对于多线程的实现，优先考虑的就是Runnable接口实现，并且永恒都是通过Thread类对象启动多线程！
