多线程，多线程的几个方法在一般研发中不太使用，在高并发的框架级别的时候会使用到

1 多线程作用
为了让程序可以处理多个请求而不阻塞程序、等待…
2 Java中创建多线程有2中方式
2.1.1创建一个类MyRunnable实现Runnable接口
2.1.2重写run方法
2.1.3创建一个main（相当于另一个线程）
2.1.4在main方法中实现MyRunnable实例
2.1.5在main方法中实现Thread实例，将MyRunnable实例传参如Thread实例中
2.1.6Thread实例调用.start()方法启动线程

 public class MyRunnable implements Runnable{
     @Override
     public void run(){
         //获取线程名，currentThread（当前线程）
        String name=Thread.currentThread().getName();
        System.out.println("线程A"+name);
     }
 }

public static void main(String[] args) {
    MyRunnable myRunnable=new MyRunnable();
    Thread thread=new Thread(myRunnable);
    thread.start();
    System.out.println("线程B");
}

2.2.1创建一个MyThread类继承Thread类
2.2.2重写run方法
2.2.3在main方法中创建一个MyThread实例
2.2.4用MyThread实例调用.start()方法启动线程（因为这个方法是父类的，子类继承来的）

public class MyThread extends Thread{
    @Override
    public void run(){
        //获取线程名，currentThread（当前线程）
        String name=Thread.currentThread().getName();
        System.out.println("线程A"+name);
    }
}

public static void main(String[] args) {
    MyThread myThread=new MyThread();
    myThread.start();
    MyThread myThread1=new MyThread();
    myThread1.start();
    MyThread myThread2=new MyThread();
    myThread2.start();
    MyThread myThread3=new MyThread();
    myThread3.start();
    System.out.println("线程B");
}

创建多个子线程时，执行结果

是因为每次都是创建了一线程，跟调用不同，调用会等被调代码执行结束继续执行，main方法相当主线程，创建一个线程后不会等，继续执行main方法的后续代码，每个线程的执行快慢也不同，就会出现上图中的情况
两种方法的实现调用.start();方法不是调用run()方法，而是启动了一个线程，只是这个线程执行了run()方法，其实真正的执行也就是这个线程执行run()方法
3 实现Runnable接口比继承Thread类所具有的优势：
3.1：适合多个相同的程序代码的线程去处理同一个资源
3.2：可以避免java中的单继承的限制（Java中一个类可以实现多个接口，但是只能继承一个类）
3.3：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
4 一个线程的生命周期

5 线程的优先级，实际工作中，基本不太用到该功能
5.1不是优先级高的执行完，优先级低的才执行
5.2而是系统分配给优先级高的线程的资源多（所以就执行完的快），分配给优先级低的线程的资源少（所以就执行完的慢），就算设置了优先级，线程也是同时在执行的
在 myThread.start();的上一行设置优先级:.setPriority();传入int参数，例：
设置为1的线程优先级就是最高的，获得的资源最多
例：

public static void main(String[] args) {
    MyThread myThread=new MyThread();
    myThread.setPriority(1);
    myThread.start();
    MyThread myThread1=new MyThread();
    myThread1.setPriority(2);
    myThread1.start();
    MyThread myThread2=new MyThread();
    myThread2.setPriority(3);
    myThread2.start();
    MyThread myThread3=new MyThread();
    myThread3.setPriority(4);
    myThread3.start();
    System.out.println("线程B");
}

6 对于工作中还是使用单线程的操作是对于业务代码而言都是单线程的，大批量请求让用户不等待，服务器不卡死，不阻塞是用户都在创建的线程池里，在最开始就创建了多线程，但是对于每个用户自己而言还是单线程的业务；一份业务代码不代表执行过程中就是单线程的
7 设置线程的睡眠时间；单位是毫秒 Thread.sleep(100);设置线程的睡眠时间是100毫秒
8 合并线程join();
调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行，与直接调用方法有点类似

public class MyThread extends Thread{
    @Override
    public void run(){
        //获取线程名，currentThread（当前线程）
        String name=Thread.currentThread().getName();
        System.out.println("线程A"+name);
    }
}


public static void main(String[] args) {
    MyThread myThread=new MyThread();
    myThread.start();
//        try {
//            myThread.join();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
    System.out.println("线程B");
}
}

不设置线程合并，线程B不会等待线程A执行完毕才执行（就是被注释掉的那段代码）

public class MyThread extends Thread{
    @Override
    public void run(){
        //获取线程名，currentThread（当前线程）
        String name=Thread.currentThread().getName();
        System.out.println("线程A"+name);
    }
}


public static void main(String[] args) {
    MyThread myThread=new MyThread();
    myThread.start();
    try {
        myThread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("线程B");
}

在线程B中，线程A调用了.join9()方法，那么线程B就会等到线程A执行完毕再继续执行，从两次输出结果就能看出