一、创建线程

1.使用Thread类

        Thread t = new Thread(){
            //创建线程对象，重写run方法
            @Override
            public void run() {
                //此处是该线程要执行的内容
                log.debug("Running");
            }
        };
        t.setName("t1");
        t.start();

2.使用Runnable接口

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                log.debug("Running");
            }
        };
        Thread t = new Thread(runnable);
        t.setName("t1");
        t.start();

由于Runnable接口中只有一个方法，并且含有@FunctionalInterface注解，所以Runnable接口为函数式接口，可以使用lambda表达式简化代码，如下：

        Thread t = new Thread(() -> log.debug("running"),"t1");
        t.start();

Thread与Runnable之间的关系
首先我们创建Runnable对象时，重写的是Runnable接口自身的run()方法：

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

当我们把Runnable对象传入Thread构造方法时，会调用init()方法，并将Runnable对象传入：

    /**
     * Allocates a new {@code Thread} object. This constructor has the same
     * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
     * {@code (null, target, name)}.
     *
     * @param  target
     *         the object whose {@code run} method is invoked when this thread
     *         is started. If {@code null}, this thread's run method is invoked.
     *
     * @param  name
     *         the name of the new thread
     */
    public Thread(Runnable target, String name) {
        init(null, target, name, 0);
    }

进入init()方法后，我们会发现Thread重载了init()方法，继续传入Runnable对象

    /**
     * Initializes a Thread with the current AccessControlContext.
     * @see #init(ThreadGroup,Runnable,String,long,AccessControlContext,boolean)
     */
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null, true);
    }

再次进入重载后的init()方法，我们发现会将Runnable对象传给Thread类中的定义好的变量：

/**
     * Initializes a Thread.
     *
     * @param g the Thread group
     * @param target the object whose run() method gets called
     * @param name the name of the new Thread
     * @param stackSize the desired stack size for the new thread, or
     *        zero to indicate that this parameter is to be ignored.
     * @param acc the AccessControlContext to inherit, or
     *            AccessController.getContext() if null
     * @param inheritThreadLocals if {@code true}, inherit initial values for
     *            inheritable thread-locals from the constructing thread
     */
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;

        Thread parent = currentThread();
        SecurityManager security = System.getSecurityManager();
        if (g == null) {
            /* Determine if it's an applet or not */

            /* If there is a security manager, ask the security manager
               what to do. */
            if (security != null) {
                g = security.getThreadGroup();
            }

            /* If the security doesn't have a strong opinion of the matter
               use the parent thread group. */
            if (g == null) {
                g = parent.getThreadGroup();
            }
        }

        /* checkAccess regardless of whether or not threadgroup is
           explicitly passed in. */
        g.checkAccess();

        /*
         * Do we have the required permissions?
         */
        if (security != null) {
            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }

        g.addUnstarted();

        this.group = g;
        this.daemon = parent.isDaemon();
        this.priority = parent.getPriority();
        if (security == null || isCCLOverridden(parent.getClass()))
            this.contextClassLoader = parent.getContextClassLoader();
        else
            this.contextClassLoader = parent.contextClassLoader;
        this.inheritedAccessControlContext =
                acc != null ? acc : AccessController.getContext();
        // 此处将我们之前传入的Runnable对象赋给Thread类中的target
        this.target = target;
        setPriority(priority);
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;

        /* Set thread ID */
        tid = nextThreadID();
    }

最后我们发现，最终还是执行Thread类中的run方法，如果Runnable对象不为空，则会执行。

    /**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * <p>
     * Subclasses of <code>Thread</code> should override this method.
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

3.使用FutureTask创建线程并获取执行结果

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask(() -> {
            log.debug("Running");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "执行成功";
        });

        Thread t1 = new Thread(futureTask,"t1");
        t1.start();
        //获取执行结果，等待t1线程执行完成，会使main线程进入阻塞状态。
        String result = futureTask.get();
        log.debug("{}",result);
    }

二、多线程执行现象

    public static void main(String[] args) {

        //开启两个线程
        new Thread(() -> {
            while (true) {
                log.debug("Running");
            }
        }, "t1").start();

        new Thread(() -> {
            while (true) {
                log.debug("Running");
            }
        }, "t2").start();

    }

输出结果：

21:55:06.733 DEBUG [t2] com.dxf.线程执行现象.Test1 - Running
21:55:06.733 DEBUG [t2] com.dxf.线程执行现象.Test1 - Running
21:55:06.733 DEBUG [t2] com.dxf.线程执行现象.Test1 - Running
21:55:06.733 DEBUG [t2] com.dxf.线程执行现象.Test1 - Running
21:55:06.733 DEBUG [t2] com.dxf.线程执行现象.Test1 - Running
21:55:06.733 DEBUG [t2] com.dxf.线程执行现象.Test1 - Running
21:55:06.733 DEBUG [t1] com.dxf.线程执行现象.Test1 - Running
21:55:06.733 DEBUG [t1] com.dxf.线程执行现象.Test1 - Running
21:55:06.733 DEBUG [t1] com.dxf.线程执行现象.Test1 - Running
21:55:06.733 DEBUG [t1] com.dxf.线程执行现象.Test1 - Running

结论：两条线程会并行交替执行，谁先谁后不由我们控制，由底层的任务调度器来决定的。