多线程的入门基础

多线程的基本概念

进程

进程就是系统中正在运行的一个程序，程序一旦运行就是一个进程，在一个进程中可以开启多个不同的线程执行

线程

在同一个进程开启了多条不同的执行路径，每条执行路径就是一个线程，多条不同路径同时执行，进程是线程的集合

多线程的好处

• 使用多线程可以提高程序效率
• 快速响应给客户端，给用户更好的体验
• 每个线程之间相互不影响

多线程的应用场景

一些比较耗时的业务逻辑采用多线程处理

线程上下文切换

对于单核CPU来说，CPU在同一个时刻只能运行一个线程，当正在运行
的线程切换到另外一个线程时，这个过程可以理解为cpu上下文切换，比如:
多核处理器，6核 12线程，指的是同一个时刻有12个线程在执行，服务器支持的线程数越高可以减少cpu上下文的切换，从而提高效率。
注意：单核的服务器开启了多线程，人为感知是多线程，但是真正意义上的底层不是多线程

线程真的开启越多越好

如果项目比较小的情况下，可以采用多线程异步实现处理也是可以的，但是如果在高并发的情况下频繁的创建线程，同时也会被cpu分配调度，不断的切换，对服务器影响也是比较大的，所以高并发的情况下一般采用mq异步处理

多线程的创建方式

第一种继承Thread类。

package com.mayikt;

/**
 * @Description:
 * @Author: ChenYi
 * @Date: 2020/07/18 10:02
 **/

public class MyThread001 extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"子线程 ");
    }

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"主线程");
        new MyThread001().start();
    }
}

第二种实现Runable接口。

package com.mayikt;

/**
 * @Description:
 * @Author: ChenYi
 * @Date: 2020/07/18 10:04
 **/

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

第三种实现Callable接口。

package com.mayikt;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
* @Description:
* @Author: ChenYi
* @Date: 2020/07/18 10:08
**/

public class MyThread003 {
   public static void main(String[] args) throws ExecutionException, InterruptedException {
       System.out.println(Thread.currentThread().getName() + "主线程>>.");
       FutureTask<String> futureTask = new FutureTask<>(() -> {
           System.out.println(Thread.currentThread().getName() + "子线程");
           Thread.sleep(3000);
           return "获取返回结果>>>";
       });
       new Thread(futureTask).start();
       String result = futureTask.get();
       System.out.println(result);
   }
}

第四种使用线程池。

package com.mayikt;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
* @Description:
* @Author: ChenYi
* @Date: 2020/07/18 10:21
**/

public class MyThread004 {
   public static void main(String[] args) {
       System.out.println(Thread.currentThread().getName() + "主线程");
       ExecutorService executorService = Executors.newCachedThreadPool();
       executorService.execute(() -> System.out.println(Thread.currentThread().getName() + "子线程"));
   }
}

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

用户线程当我们主线程停止掉后，用户线程不会随着主线程停止，
守护线程当我们主线程停止掉后，守护线程也会跟着停止。
守护线程的使用场景：GC线程
java默认创建的都是用户线程
用户线程和守护线程的代码。

package com.mayikt;

/**
* @Description:
* @Author: ChenYi
* @Date: 2020/07/18 10:51
**/

public class MyThread005 {
   public static void main(String[] args) {
       Thread thread = new Thread(() -> {
           while (true) {

           }
       });
       //true为守护线程 ，false为用户线程 默认是为false用户线程
       thread.setDaemon(true);
       thread.start();

       System.out.println(Thread.currentThread().getName()+"执行完毕");
   }
}

如何优雅的停止一个线程

官方不建议直接调用stop方法停止该线程，建议采用中间件变量值的停止该线程，因为stop方法是强制关闭线程，可能会存在业务逻辑还没有处理完的情况
代码

package com.mayikt;

/**
 * @Description:
 * @Author: ChenYi
 * @Date: 2020/07/18 11:04
 **/

public class MyThread006 extends Thread {
    private boolean flag = true;
    @Override
    public void run() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while (flag){

        }
    }
    public void stopThread(){
        flag = false;
    }

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"主线程");
        MyThread006 myThread006 = new MyThread006();
        myThread006.start();
        myThread006.stopThread();
    }
}

多线程五种的状态

1. 当我们新建一个线程的 时候，new Thread的时候为新建的状态
2. 当我们调用到start方法的时候，不会立马执行到我们的run方法，当前线程状态为就绪状态，需要等待cpu的切换
3. 当cpu切换到能够调用该线程的时候，当前线程的状态为运行状态
4. 当我们在线程调用sleep方法的时候，当前的线程状态为阻塞状态，当休眠的时间过了的时候需要等待cpu调度，从就绪状态到运行状态
5. 当我们线程调用stop方法或者run方法代码执行结束的时候，当前线程的状态为死亡状态
   
   参考：蚂蚁课堂