1.start和run的区别

1.start方法内部，是会调用到系统api，来在系统的内核中创建出线程。
2.run方法，单纯的描述了该线程要执行什么内容，会在start 创建好线程之后自动被调用的。
3.本质上差别在于是否在系统的内部创建出新的线程。
调用start 方法，才真的在操作系统的底层创建出一个线程。
举例：
*run方法相当于执行清单
*线程对象相当于执行任务的人
*调用start方法相当于喊一声命令去执行

2.创建线程的五种写法

1.继承Thread,重写run

Main和run兵分两路，并发执行

package thread;
class MyThread extends Thread{
    @Override
    public void run() {
        while(true){
        System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }}
}
public class demo1 {
    public static void main(String[] args) throws InterruptedException {
    Thread t= new MyThread();
    t.start();
    while(true){
        System.out.println("hello main");
    Thread.sleep(1000);
    }
    }
}

2.实现runnable，重写run

注意：runnable表示的是一个可以执行的任务，本身自己不能执行，所以要放到其他实体里，通过start操作，来调用系统api来创建线程。

class MyRunnable implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class demo2 {
    public static void main(String[] args) throws InterruptedException {
        Runnable runnable =new MyRunnable();
        Thread t=new Thread(runnable);
        t.start();
        while(true){
            System.out.println(" hello main");
            Thread.sleep(1000);
        }
    }
}

3.继承Thread,重写run,使用匿名内部类

 public static void main(String[] args) throws InterruptedException {
        Thread t= new Thread(){
            @Override
            public void run() {
                while (true){
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();
        while(true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

4.实现Runnable,重写run,使用匿名内部类

public class demo10 {
    public static void main(String[] args) throws InterruptedException {
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("hello Thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        Thread t= new Thread(runnable);
        t.start();
        while(true){
            System.out.println("hello main");
         Thread.sleep(1000);}
    }
}

5.使用lambda表达式

lambada表达式是更简化的语法表示方式
相当于“匿名内部类”的代替写法

public class demo11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            while(true){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        while(true){
            System.out.println("hello main");
       Thread.sleep(1000); }
    }
}