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

时间 2020-07-06

标签去年阿里面试被问 java 多线程这样栏目阿里巴巴繁體版

原文原文链接

1.多线程的基本概念

1.1进程与线程

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

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

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

线程其实是在进程基础之上的进一步划分，一个进程启动以后，里面的若干执行路径又能够划分红若干个线程编程

1.2并行与并发

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

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

1.3同步与异步

同步:排队执行 , 效率低可是安全.多线程

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

1.4线程的调度

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

Java使用的为抢占式调度。ide

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对象。静态和非静态方法的锁互不干预。一个线程得到锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。对于同步，要时刻清醒在哪一个对象上同步，这是关键。编写线程安全的类，须要时刻注意对多个线程竞争访问资源的逻辑和安全作出正确的判断，对“原子”操做作出分析，并保证原子操做期间别的线程没法访问竞争资源。当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。死锁是线程间相互等待锁锁形成的，在实际中发生的几率很是的小。真让你写个死锁程序，不必定好使，呵呵。可是，一旦程序发生死锁，程序将死掉。