创建线程的两种方式

1 Thread类

1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象
3. 调用线程对象的start()方法来启动该线程

代码如下：

线程类

public class MyThread extends Thread{
    @Override
    public void run() {
//        String name = getName();
//        System.out.println(name);
        Thread th = Thread.currentThread();
        System.out.println(th);//Thread[Thread-0,5,main]
        System.out.println(th.getName());//Thread-0

    }
   
}

测试类：

public class Thread03 {
    public static void main(String[] args) {
        MyThread mt=new MyThread();
        mt.start();//Thread-0


        new MyThread().start();//Thread-1
        new MyThread().start();//Thread-2
        //获取主线程的名称
        System.out.println(Thread.currentThread().getName());//main
        //修改线程名称
        Thread.currentThread().setName("mmmm");
        System.out.println(Thread.currentThread().getName());//mmmm

        //开启多线程
        new MyThread("okc").start();//okc
    }
}

2 Runnable接口

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可
实现步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法，开启新的线程执行run方法

Java.lang.Thread类的构造方法
Thread(Runnable target) 分配新的Thread对象
Thread（Runnable target，String name） 分配新的Thread对象

代码如下：

实现类：

//1.创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable {
    //2.在实现类中重写run方法，设置线程任务
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

测试类：

public class Thread04 {
    public static void main(String [] args){
        //3.创建一个Runnable接口的实现类对象
        RunnableImpl r1=new RunnableImpl();
        //4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t1=new Thread(r1);
        //调用Thread类中的start方法，开启新的线程执行run方法
        t1.start();//Thread-0
        System.out.println(Thread.currentThread().getName());//main
        //Thread（Runnable target，String name） 分配新的Thread对象,并确定线程名称
        Thread t2=new Thread(r1,"hahaha");
        t2.start();//hahaha
    }

}

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target)
构造出对象，然后调用Thread 对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。
因此，不管是继承Thread类还是实现 Runnable接口来实现多线程，
最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程 
编程的基础。

3 Thread和Runnable的区别

• 如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享

实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去共享同一个资源。

2. 可以避免java中的单继承的局限性。

3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。

4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

    扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个
    是垃圾收集线程。因为每当使用 java命令执行一个类的时候，实际上都会启
    动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程
   

4 匿名内部类方式实现线程的创建

匿名：没有命名；内部类：*写在其它类内部的类

• 匿名内部类作用：简化代码
  1.把子类继承父类，重写父类的方法，创建子类对象合为一步完成
  2.把实现类实现接口，重写接口中的方法，创建实现类对象合成一步完成
  匿名内部类的最终产物：子类/实现类对象，而这个类没有名字
  格式：
  new 父类/接口(){
  重写父类/接口中的方法
  };

public class Thread05 {
    public static void main(String[] args) {
        //线程的父类是Thread
        new Thread(){
            //重写run方法设置线程任务
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }.start();//Thread-0

        //线程的接口Runnable
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();//Thread-1

    }
}