线程之间的执行是相互独立的，哪一个线程优先执行取决于OS的调度

线程的创建方式：

实现Runnable接口：

• 创建自定义类并实现runnable接口，且实现接口中的run方法；
• 实例化自定义的类；
• 将自定义类的实例作为参数传给Thread类，创建thread实例；
• 调用thread实例的start，启动子线程；

普通方式

package ThreadDemo;

class Thread1 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"子线程");
    }
}
public class RunnableDemo {
    public static void main(String[] args) {
          Thread1 thread1=new Thread1();
          Thread thread=new Thread(thread1);
          thread.start();
    }
}

lambda表达式呈现：

public class RunnableDemo {
    public static void main(String[] args) {
          Thread thread=new Thread(()->{
              System.out.println(Thread.currentThread().getName()+"子线程");
          });
          thread.start();
    }
}

继承Thread类创建线程

• 创建自定义类并继承Thread类，并且重写run方法；
• 实例化自定义类
• 通过实例化对象调用start方法来创建线程；

package ThreadDemo;

class Thread1 extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"子线程");
    }
}
public class RunnableDemo {
    public static void main(String[] args) {
          Thread1 thread1=new Thread1();
          thread1.start();
    }
}

实现Callable接口：线程池提供的一种创建线程的方式；

• 实现Callable接口，并实现它的call方法；
• 创建线程池（Executors工具类提供的方法创建线程池）；
• 创建Callable接口实现类的实例；
• 将实例对象通过线程池的submit（提交）方法提交给线程池进而创建新的线程；

package ThreadDemo;

import java.util.concurrent.*;

class Thread2<T> implements Callable<T> {
    @Override
    public T call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return null;
    }
}
public class RunnableDemo {
    public static void main(String[] args) {
        ExecutorService executor= Executors.newSingleThreadExecutor();
         Thread2<Integer> thread2=new Thread2();
         Future<Integer>future= executor.submit(thread2);
        try {
            Integer integer=future.get();
            future.cancel(true);
            //用于取消异步的任务，它传入一个boolean类型的参数，传入true会中断线程停止任务，
            // 而传入false则会让线程正常执行至完成，并返回false。 
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

线程操作的相关方法介绍：

• void start(): 启动一个新的线程，start方法必须是子线程第一个调用的方法，start方法不能够重复调用（否则会抛异常），新线程会调用runnable接口提供的run方法；
• void run(): run方法是子线程的执行体，子线程从进入run方法开始直至run方法结束，意味着子线程的任务执行结束；在主线程直接调用run方法是不能创建子线程的，只是普通方法调用；
• yield（）： 让步或者暂停，Thread类的静态方法。让正在执行的线程停止或者让步，让给优先级较高的线程获取CPU的执行权（不一定会让出CPU执行权，如等待的线程优先级较低或者当前线程只有一个线程在执行时，那么当前线程又会立即获取CPU的执行权）
  thread.yield() == 》 thread ！= 正在执行的线程 ==》 静态方法通过实例调用，但是跟实例没有任何关系；
• static native void sleep(long millis) throws InterruptedException： sleep方法作用是让线程进行休眠，即让线程阻塞住，Thread类提供的静态方法，会抛出InterruptedException异常；
• join（）： 等待线程执行结束才继续执行，会抛出InterruptedException异常；
  假如在a线程中b线程进行 b.join（） 调用，那么a线程执行结束才能继续执行，控制多线程按照次序执行；
• interrupt(): 中断方法，底层调用native方法，native方法的作用是对特定标识位做出修改，主要作用于线程：运行中线程，阻塞线程（sleep/join）
  运行中线程： interrupt方法仅仅是对标志位做了修改，其它没有影响；
  阻塞线程： interrupt方法对标志位做了修改，另阻塞中的线程感知到标志位做了修改，就会中断当前的阻塞状态，抛出InterruptedException异常；
• boolean isInterrupted(): 判断是否发生了中断操作，true表示发生了中断，false 表示未发生中断；
• setPriority(int newPriority): 设置线程优先级，优先级分为10级，优先级数字越大，即优先级越高，优先级越高，被优先调用的概率会增大；但是不一定会被优先执行，还是要看本地操作系统的
  MIN_PRIORITY=1; 最小优先级；
  NORM_PRIORITY=5 ; 默认优先级；
  MAX_PRIORITY=10 ; 最大优先级；
• int getPriority(): 返回当前程序的优先级；
• setDaemon(boolean on): 设置守护线程，true：设置为守护线程，false：用户线程； 线程不进行设置，默认为用户线程；
• boolean isDaemon(): 判断当前线程是否为守护线程；

守护线程：

脱离于控制终端，作为提供通用服务的线程存在。

用户线程和守护线程的区别：

• 生命周期：守护线程的生命周期是依赖于用户线程，当有用户线程存在，守护线程就会存活，当没有用户线程存在，那么守护线程也会随之消亡。垃圾回收是有单独线程来处理的，负责垃圾回收的线程就是守护线程；

为什么sleep和yield方法是静态的：

sleep分析：为什么不设计成非静态的，当实例调用时，该实例休眠 ？

• 如果是实例方法，就可以实现在一个线程里随时让其它线程在执行中休眠，而且这种休眠是不放弃锁的。那么这种简单粗暴就很容易引起混乱，因此目前这种机制其实就是一种限制：你可以选择给自己吃安眠药，而不能随便给正在工作的别人吃安眠药；

• 线程和实例并不是对等的，不是一个线程是一个实例，是你创建的实例继承了Thread或者Runable，实现了run(),并调用start()的时候能执行多个线程，实例还是一个，线程却是多个。所以实例休眠线程就休眠了这个假设不成立。

yield分析：

yield()是建议线程调度程序从当前线程中让出CPU时间给别的线程，这是一种总体调度，不是仅仅和某个线程相关的，而是和每个线程都有关。线程和人不一样，不是当前线程让了，别的线程就会来抢，是需要调度程序来调度的。

关于sleep()方法和yield()方法的区别如下：

• sleep()方法暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级；但yield()方法只会给优先级相同，或优先级更高的线程执行机会。

• sleep()方法会将线程转入阻塞状态，直到经过阻塞时间才会转入就绪状态；而yield()方法不会将线程转入阻塞状态，它只是强制当前线程进入就绪状态。因此完全有可能某个线程调用yield()方法暂停之后，立即再次获得处理器资源被执行。

• sleep()方法声明抛出了InterruptedException异常，所以调用sleep()方法时要么捕捉该异常，要么显式声明抛出该异常；而yield()方法则没有声明抛出任何异常。

• sleep()方法比yield()方法有更好的可移植性，通常不建议使用yield()方法来控制并发线程的执行。

1，继承Thread类

继承Thread类,重写run方法(不推荐,因为java的单继承局限性)

public class ExtendThread extends Thread {

    /*
    * 创建步骤如下：
    * 1，定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务。因此把run方法称为线程执行体。
    * 2，创建Thread子类了的实例，即创建线程对象。本实例中是new一个ExtendThread，即可创建线程对象，也就是开启了一个线程
    * 3，调用线程对象的start()方法来启动该线程。
    *
    * 调用示例：
    * //循环10次即开启10个线程
    * for (int i = 0; i < 10; i++) {
    *     ExtendThread extendThread = new ExtendThread();
    *     extendThread.start();
    * }
    * */

    /**
     * 重写Thread类的run()，这个方法称为线程执行体
     * */
    @Override
    public void run() {
        doSomething();
    }

    /**
     * 需要处理的任务
     * */
    public void doSomething(){
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "执行" + i);
        }
    }
}

2，实现Runnable接口

方式一：直接实现Runnable接口(避免单继承的局限性,方便共享资源,推荐使用)

public class RunnableImpl implements Runnable {

    /*
    * 创建步骤如下：
    * 1，定义Runnable接口的实现类，并且实现run方法，这个方法同样是线程执行体
    * 2，创建Runnable实现类的实例，并以此实例对象作为Thread的target来创建Thread类，这个新创建的Thread对象才是真正的线程对象，即开启了新的线程
    * 3，调用线程对象的start()方法来开启该线程
    *
    * 调用示例：
    * //开启10个线程
    * for (int i = 0; i < 10; i++) {
    *     Thread thread = new Thread(new RunnableImpl());
    *     thread.start();
    * }
    * */

    /**
     * 实现Runnable接口的run方法，这个方法称为线程执行体
     * */
    @Override
    public void run() {
        doSomething();
    }

    /**
     * 需要处理的任务
     * */
    private void doSomething(){
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "执行" + i);
        }
    }
}

方式二：匿名内部类

public class Anonymous {

    /*
    * 创建步骤如下：
    * 匿名内部类本质上也是一个类实现了Runnable接口，重写了run方法，只不过这个类没有名字，直接作为参数传入Thread类
    *
    * 调用示例：
    * //开启10个线程
    * for (int i = 0; i < 10; i++) {
    *     Anonymous anonymous =new Anonymous();
    *     anonymous.myRun();
    * }
    *
    * */

    public void myRun(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                doSomething();
            }
        }).start();
    }

    /**
     * 需要处理的任务
     * */
    private void doSomething(){
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "执行" + i);
        }
    }
}

3，实现Callable接口

public class CallableImpl implements Callable<String> {

    /*
     * 创建步骤如下：
     * 1，定义实现Callable<V>接口的实现类，实现call方法，这个方法是线程执行体
     * 2，创建Callable<V>实现类的实例，借助FutureTask得到线程执行的返回值
     * 3，将FutureTask的实例，作为Thread的target来创建Thread类
     * 4，调用start方法，开启线程
     *
     * 调用示例：
     * Callable<String> tc = new CallableImpl();
     * FutureTask<String> task = new FutureTask<>(tc);
     * new Thread(task).start();
     * try {
     *     System.out.println(task.get());
     * } catch (InterruptedException | ExecutionException e) {
     *     e.printStackTrace();
     * }
     *
     * 说明：
     * 1.与使用Runnable相比， Callable功能更强大些
     * 2.实现的call()方法相比run()方法，可以返回值
     * 3.方法可以抛出异常
     * 4.支持泛型的返回值
     * 5.需要借助FutureTask类，比如获取返回结果
     * Future接口可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
     * FutureTask是Futrue接口的唯一的实现类
     * FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
     *
     * */

    private int ticket = 5;

    @Override
    public String call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(doSomething());
        }

        return "出票任务完成";
    }

    public String doSomething() {
        String result = "";
        if (this.ticket > 0) {
            result = "出票成功，ticket=" + this.ticket--;
        } else {
            result = "出票失败，ticket=" + this.ticket;
        }
        return result;
    }
}

4，创建线程池

public class ThreadPool implements Runnable {

    /*
     * 创建步骤如下：
     * 1，定义Runnable接口的实现类，或者定义（继承Runnable接口的类）的实现类，并且实现run方法，这个方法是线程执行体
     * 2，创建一个自定义线程个数的线程池
     * 3，实例化Runnable接口的实现类
     * 4，将3步的实例，作为线程池实例的execute方法的command参数，开启线程
     * 5，关闭线程池
     *
     * 调用示例：
     * ExecutorService pool = Executors.newFixedThreadPool(2);
     * ThreadPool threadPool = new ThreadPool("AA");
     * ThreadPool threadPoo2 = new ThreadPool("BB");
     * pool.execute(threadPool);
     * pool.execute(threadPoo2);
     * pool.shutdown();
     *
     * 说明：
     * 示例中创建的是2个线程的线程池
     * execute方法是开启线程方法，实参要求是实现Runnable的类。所以，继承Thread类的子类也可以以线程池的方式开启线程
     *
     * */

    String name;
    public ThreadPool(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        doSomething();
    }

    /**
     * 需要处理的任务
     * */
    private void doSomething() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "执行" + i + "，name=" + this.name);
        }
    }
}

1.start
使用start方法才真正实现了多线程运行，因为使用start（）方法不用等待run方法体代码执行完毕而直接继续执行下面的代码。
因为thread线程有5种状态，创建-就绪-运行-阻塞-死亡这五种，用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，等到cpu空闲时，才会执行线程里面的run方法，run方法运行完毕，此线程结束。

2.run
因为run方法是thread里面的一个普通的方法，直接调用run方法，这个时候它是会运行在我们的主线程中的，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到多线程的目的。

代码示例：

public class ThreadDemo {
    public static void main(String[] args){
        Thread thread1 = new Thread(new MyRunnable());
        Thread thread2 = new Thread(new MyRunnable());
        thread1.start();
        thread2.start();
    }
}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                Thread.sleep(100);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

两个线程都是使用start方法开启的，所以并不需要等待另一个完成，所以他们的执行顺序应该是并行的，我们运行看一下结果：

和我们分析的一样，那么我们改改代码，执行使用run方法，看看是否顺序执行

 public static void main(String[] args){
    Thread thread1 = new Thread(new MyRunnable());
    Thread thread2 = new Thread(new MyRunnable());
    thread1.run();
    thread2.run();
}

总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。