创建线程的一般方式，匿名内部类方式，lamda表达式对比——实现runnable接口，重写run方法

启动：使用静态代理设计模式

优点：可同时实现继承，避免单继承局限性

一般方式：

Programer.java

/**
 * 真实角色
 *
 * @author :liuqi
 * @date :2018-06-12 17:39.
 */
public class Programer implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("一边coding: ");
        }
    }
}

测试类

Demo03.java

/**
 * 测试类：一般方式之实现runnable接口创建线程
 *
 * @author :liuqi
 * @date :2018-06-12 17:44.
 */
public class Demo03 {
    public static void main(String[] args) {
        // 创建真实角色
        Programer pro = new Programer();
        // 创建代理角色+真实角色引用
        Thread proxy = new Thread(pro);
        // 调用start方法启动线程
        proxy.start();
        for (int i = 0; i < 7; i++) {
            System.out.println("一边聊QQ");
        }
    }
}

运行结果：

一边聊QQ
一边聊QQ
一边聊QQ
一边聊QQ
一边聊QQ
一边聊QQ
一边聊QQ
一边coding:
一边coding:
一边coding:
一边coding:
一边coding:

匿名内部类方式：

ThreadDemo.java

/**
 * 使用匿名内部类的方式创建线程
 *
 * @author :liuqi
 * @date :2018-06-12 15:02.
 */
public class ThreadDemo {
    // 继承thread类实现多线程
    public static void main(String[] args) {
        /*new Thread() {
            @Override
            public void run() {
                for (int x = 0; x < 5; x++) {
                    *//*System.out.println(Thread.currentThread().getName() + "--"
                            + x);*//*
                    System.out.println("rabit run " + "--"
                            + x);
                }
            }
        }.start();
        ;
        new Thread() {
            @Override
            public void run() {
                for (int x = 0; x < 5; x++) {
                    *//*System.out.println(Thread.currentThread().getName() + "--"
                            + x);*//*
                    System.out.println("tortoise run " + "--"
                            + x);
                }
            }
        }.start();
        ;*/
        // 实现runnable接口，创建多线程并启动
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int x = 0; x < 5; x++) {
                    System.out.println(Thread.currentThread().getName() + "--"
                            + x);
                }
            }
        }) {
        }.start();
    }
}

运行结果：

Thread-0--0
Thread-0--1
Thread-0--2
Thread-0--3
Thread-0--4

lamda表达式：

Runnable runnable = () -> {
　　for(int a=0; a>5; a++){
　　　　System.out.println(Thread.currentThread().getName() + ", a=" + a);
　　　　}
};
new Thread(() -> {runnable}, "thread 1").start();

 (lamda可以实现只有一个方法的接口，Runnable是一个只有run方法的接口，Thread 构造方法需要一个 Runnable 类型参数，所以 () -> {} 这个 lamda表达式就代表了一个 Runnable)

参考：https://www.cnblogs.com/fuck1/p/5373700.html

代码地址：https://github.com/yuki9467/TST-javademo/tree/master/src/main/thread