去年去阿里面试，被问到java 多线程，我是这样手撕面试官的

Posted 2020-12-14

1.多线程的基本概念

1.1进程与线程

程序：是为完成特定任务，用某种语言编写的一组指令的集合，即一段静态代码，静态对象。

进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，每个程序都有一个独立的内存空间

线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程

线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

?

1.2并行与并发

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）。

1.3同步与异步

同步:排队执行 , 效率低但是安全.

异步:同时执行 , 效率高但是数据不安全.

1.4线程的调度

分时调度（时间片）：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间
抢占式调度：高优先级的线程抢占CPU

Java使用的为抢占式调度。

?

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使用率更高。

1.5线程的优先级

Java线程有优先级，优先级高的线程会获得较多的运行机会。

java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：

static int MAX_PRIORITY
? ? ? ? ? 线程可以具有的最高优先级，取值为10。
static int MIN_PRIORITY
? ? ? ? ? 线程可以具有的最低优先级，取值为1。
static int NORM_PRIORITY
? ? ? ? ? 分配给线程的默认优先级，取值为5。

Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。
主线程的默认优先级为Thread.NORM_PRIORITY。
setPriority(int newPriority):改变线程的优先级
高优先级的线程要抢占低优先级的线程的cpu的执行权。但是仅是从概率上来说的，高优先级的线程更有可能被执行。并不意味着只有高优先级的线程执行完以后，低优先级的线程才执行。

2.三种多线程的创建方式

2.1 继承于Thread类

1.创建一个集成于Thread类的子类 （通过ctrl+o（override）输入run查找run方法）
2.重写Thread类的run（）方法
3.创建Thread子类的对象
4.通过此对象调用start（）方法

public class MyThread extends Thread{
    /*
     run方法就是线程要执行的任务方法
     */
    @Override
    public void run() {
        //这里的代码就是一条新的执行路径
        //这个执行路径的触发方法，不是调用run方法，而是通过Thread对象的start（）来起启动任务
       for (int i=0;i<10;i++){
           System.out.println("大大大"+i);
       }
    }
}

 public static void main(String[] args) {
        MyThread m = new MyThread();
        m.start();
        for (int i=0;i<10;i++){
            System.out.println("小星星"+i);
        }

2.2? 实现Runable接口方式

1.创建一个实现了Runable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类中的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start（）

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程的任务
        for (int i=0;i<10;i++){
            System.out.println("床前明月光"+i);

        }

    }
}

       //1.  创建一个任务对象
        MyRunnable r = new MyRunnable();
        //2.  创建一个线程，并为其分配一个任务
        Thread t = new Thread(r);
        //3.   执行这个线程
        t.start();
        for (int i=0;i<10;i++){
            System.out.println("疑是地上霜"+i);

实现Runnable 与 继承Thread 相比有如下优势

1.通过创建任务，然后给线程分配的方式来实现多线程，更适合多个线程同时执行相同的任务
2.可以避免单继承带来的局限性
3.任务与线程本身是分离的，提高了程序的健壮性
4.后续学习的线程池技术，接受Runnable接口的任务，而不接受Thread类型的线程

main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。

2.3 实现Callable接口方式

1.创建一个实现callable的实现类
?2.实现call方法，将此线程需要执行的操作声明在call（）中
?3.创建callable实现类的对象
?4.将callable接口实现类的对象作为传递到FutureTask的构造器中，创建FutureTask的对象
?5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法启动（通过FutureTask的对象调用方法get获取线程中的call的返回值）

接口定义
//Callable接口
public interface Callable<V> {
?V call() throws Exception;
}

1. 编写类实现Callable接口 , 实现call方法
class XXX implements Callable<T> {
@Override
?????public <T> call() throws Exception {
???????return T;
?????}
}
2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
FutureTask<Integer> future = new FutureTask<>(callable);
3. 通过Thread,启动线程
new Thread(future).start();

Runnable与Callable的异同

相同点：都是接口
? ? ? ? ? ? ? ?都可以编写多线程程序
? ? ? ? ? ? ? ? 都采用Thread.start()启动线程

不同点：Runnable没有返回值；Callable可以返回执行结果
? ? ? ? ? ? ? ?Callable接口的call()允许抛出异常；Runnable的run()不能抛出

Callable还会获取返回值——Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

3.线程安全问题

线程安全问题是指，多个线程对同一个共享数据进行操作时，线程没来得及更新共享数据，从而导致另外线程没得到最新的数据，从而产生线程安全问题。

三种安全锁：

3.1同步代码块

使用同步监视器（锁）
Synchronized（同步监视器）{
//需要被同步的代码
}

说明：

操作共享数据的代码（所有线程共享的数据的操作的代码）（视作卫生间区域（所有人共享的厕所）），即为需要共享的代码（同步代码块，在同步代码块中，相当于是一个单线程，效率低）
共享数据：多个线程共同操作的数据，比如公共厕所就类比共享数据
同步监视器（俗称：锁）：任何一个的对象都可以充当锁。（但是为了可读性一般设置英文成lock）当锁住以后只能有一个线程能进去（要求:多个线程必须要共用同一把锁，比如火车上的厕所，同一个标志表示有人）

3.2同步方法

使用同步方法，对方法进行synchronized关键字修饰。将同步代码块提取出来成为一个方法，用synchronized关键字修饰此方法。对于runnable接口实现多线程，只需要将同步方法用synchronized修饰而对于继承自Thread方式，需要将同步方法用static和synchronized修饰，因为对象不唯一（锁不唯一）
?

3.3显示锁

Lock 子类 ReentrantLock

3.4公平锁与非公平锁

显示锁 的fair参数为true 就表示是公平锁? ?先到先得

public static void main(String[] args) {
        //线程不安全
        //同步代码块 和 同步方法 都属于隐式锁
        //解决方案3.显示锁 Lock 子类 ReentrantLock
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();

    }
    static class Ticket implements Runnable{
        private int count = 10;
        // 票数
        //显示锁 l : fair参数为true  就表示是公平锁
        private Lock l = new ReentrantLock(true);
        @Override
        public void run() {
            while (true) {
                l.lock();  //锁住
                if (count > 0) {
                    System.out.println("正在准备卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;  //卖票
                    System.out.println(Thread.currentThread().getName() + "出票成功，余票" + count);
                }else {
                    break;
                }
                l.unlock();//开锁
            }
        }
    }

3.5出现死锁问题

出现死锁以后，不会出现提示，只是所有线程都处于阻塞状态，无法继续

死锁的解决办法：

1.减少同步共享变量
2.采用专门的算法，多个线程之间规定先后执行的顺序，规避死锁问题
3.减少锁的嵌套。

4.线程通信问题

通信常见方法：

这三种方法只能在同步代码块或同步方法中使用。

线程通信的应用：生产者/消费者问题
??1.是否是多线程问题？是的，有生产者线程和消费者线程（多线程的创建，四种方式）
??2.多线程问题是否存在共享数据？ 存在共享数据----产品（同步方法，同步代码块，lock锁）
??3.多线程是否存在线程安全问题？ 存在----都对共享数据产品进行了操作。（三种方法）
??4.是否存在线程间的通信，是，如果生产多了到20时，需要通知停止生产（wait）。（线程之间的通信问题，需要wait，notify等）
?

5.线程生命周期

线程生命周期的阶段?? ?描述

新建?? ?当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪?? ?处于新建状态的线程被start后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行?? ?当就绪的线程被调度并获得CPU资源时，便进入运行状态，run方法定义了线程的操作和功能
阻塞?? ?在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时终止自己的执行，进入阻塞状态
死亡?? ?线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

6.线程池???ExecutorService

6.1 缓存线程池

/**
  * 缓存线程池.
  * (长度无限制)
  * 执行流程:
  *   1. 判断线程池是否存在空闲线程
  *   2. 存在则使用
  *   3. 不存在,则创建线程 并放入线程池, 然后使用
  */
 ExecutorService service = Executors.newCachedThreadPool();
 //向线程池中 加入 新的任务
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });

6.2 定长线程池

/**
  * 定长线程池.
  * (长度是指定的数值)
  * 执行流程:
  *   1. 判断线程池是否存在空闲线程
  *   2. 存在则使用
  *   3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
  *   4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
  */
 ExecutorService service = Executors.newFixedThreadPool(2);
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });

6.3?单线程线程池

效果与定长线程池 创建时传入数值1 效果一致.
 /**
  * 单线程线程池.
  * 执行流程:
  *   1. 判断线程池 的那个线程 是否空闲
  *   2. 空闲则使用
  *   4. 不空闲,则等待 池中的单个线程空闲后 使用
  */
 ExecutorService service = Executors.newSingleThreadExecutor();
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });

?

6.4?周期性任务定长线程池

public static void main(String[] args) {
 /**
  * 周期任务 定长线程池.
  * 执行流程:
  *   1. 判断线程池是否存在空闲线程
  *   2. 存在则使用
  *   3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
  *   4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
  *
  * 周期性任务执行时:
  *   定时执行, 当某个时机触发时, 自动执行某任务 .
   */
 ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
 /**
  * 定时执行
  * 参数1.  runnable类型的任务
  * 参数2.  时长数字
  * 参数3.  时长数字的单位
  */
 /*service.schedule(new Runnable() {
   @Override
   public void run() {
     System.out.println("俩人相视一笑~ 嘿嘿嘿");
   }
 },5,TimeUnit.SECONDS);
 */
 /**
  * 周期执行
  * 参数1.  runnable类型的任务
  * 参数2.  时长数字(延迟执行的时长)
  * 参数3.  周期时长(每次执行的间隔时间)
  * 参数4.  时长数字的单位
  */
 service.scheduleAtFixedRate(new Runnable() {
   @Override
   public void run() {
     System.out.println("俩人相视一笑~ 嘿嘿嘿");
   }
 },5,2,TimeUnit.SECONDS);
}

7.Lambda 表达式

Lambda 体现的是函数式编程思想

Thread t = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("hhh");
    }
});
t.start();

Thread t = new Thread(() -> {
    System.out.println("hhh");
});
t.start();

这个表达式就是省略了中间的接口功能用表达式代替，保留了参数和方法部分。

8.小总结

线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。
线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法
对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。
对于同步，要时刻清醒在哪个对象上同步，这是关键。
编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。
当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。
死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。