08 启动线程；为什么说Java中只有Thread代表线程；静态代理 Thread类； 使用Lambda表达式更快捷编写线程

启动线程

线程对象在初始化完成之后，调用start()方法就可以启动这个线程。

start()方法中调用一个本地方法start0();start0()该方法会开辟空间，分配内存，分配CPU等。

为什么说Java中只有Thread代表线程

• 只有Thread代表线程，Runnable仅代表一个任务，可以被任何线程执行的任务。
• Runnable不能有返回值，不能抛出checked exception。
• Callable 可以有返回值，也能抛出异常。

Thread类的start0()方法，才会创建一个独立的方法栈。

Thread类的每一个实例代表一个JVM的线程；

public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

Runnable是一个函数式接口。

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Callable也是一个函数式接口。

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

静态代理 Thread类

个人博客：静态代理模式 https://blog.csdn.net/lingyiwin/article/details/111999623

静态代理模式：

• 代理对象和真实对象需要实现同一个接口
• 代理对象中包含一个真实角色

new Thread(()->{
    System.out.println("真是对象");
}).start();

代理对象：new Thread() 实现了runnable接口

真是对象：()->{System.out.println(“真是对象”);} lambda表达式。相当于实现了runnable接口的类，run方法为方法体为System.out.println(“真是对象”);

Lambda表达式

个人博客：Lambda expression https://blog.csdn.net/lingyiwin/category_10498912.html?spm=1001.2014.3001.5482

为什么要使用lambda表达式

• 避免匿名内部类定义过多
• 可以让代码看起来更简洁
• 去掉一堆没有意义的代码，只留下核心的逻辑。

函数式接口的定义：

• 接口内部只有一个方法，成为函数式接口
• 函数式接口，可以通过lambda表达式来创建。

lambda和java内部类的区别：详细可以参考一下lambda表达式的博客

• new LambdaInterface01() 直接简化为()
• 方法名public void fun() 简化为 ->

/**
 * lambda简化过程
 * 倘若要调用LambdaInterface接口的fun方法
 * 有如下几种方法
 *  1：实现类
 *  2：静态内部类
 *  3：局部内部类
 *  4：匿名内部实现类
 *  5：lambda表达式简化
 * lambda表达式是最简单的方法
 */
public class LambdaProcess {

    public static void main(String[] args) {
        new LambdaClass().fun();
        new LambdaStaticInnerClass().fun();

        /**
         * 3：局部内部类
         **/
        class LambdaPartInnerClass implements LambdaInterface{
            @Override
            public void fun() {
                System.out.println("3: LambdaInterface 局部内部实现类");
            }
        }
        new LambdaPartInnerClass().fun();

        /**
         * 4：匿名内部实现类
         **/
        new LambdaInterface(){
            @Override
            public void fun() {
                System.out.println("4: LambdaInterface 匿名内部实现类");
            }
        }.fun();

        /**
         * 5：lambda表达式简化
         **/
        LambdaInterface lab = () -> {
            System.out.println("5: LambdaInterface 静态内部实现类");
        };
        lab.fun();


    }

    /**
     * 2：静态内部类
     **/
    static class LambdaStaticInnerClass implements LambdaInterface{
        @Override
        public void fun() {
            System.out.println("2: LambdaInterface 静态内部实现类");
        }
    }
}


/**
 * 内部接口
 * 接口内部只有一个方法，称为函数式接口
 */
interface LambdaInterface{
    public void fun();
}

/**
 * 1:实现类
 **/
class LambdaClass implements  LambdaInterface{

    @Override
    public void fun() {
        System.out.println("1: LambdaInterface 实现类");
    }
}