小滴课堂-学习笔记: 面试必备知识之玩转并发编程技术点

logo 愿景:"让编程不再难学,让技术与生活更加有趣"


更多架构课程请访问 xdclass.net

目录

第1集 多年开发经验的你是否知道线程+进程+协程的区别

第2集 多年开发经验的你是否可以清晰表达 并发、并行的区别

第3集 新版Java多线程的实现方式你知道多少《上》

第4集 新版Java多线程的实现方式你知道多少《下》

第5集 新版Java线程的状态你知道多少?

第6集 新版Java线程的常见方法你知道多少?

第7集 新版Java线程的状态转换流程图你会画不

第8集 新版Java并发编程核心知识点掌握多少《一》

第9集 新版Java并发编程核心知识点volatile掌握多少 《二》

第10集 新版Java并发编程 指令重排/happens-before 掌握多少《三》

​干货文档


 

第1集 多年开发经验的你是否知道线程+进程+协程的区别

简介:是否掌握线程、进程、协程的区别

  • 考点:是否掌握线程、进程、协程的区别

  • 难度【***】

  • 能否解释下什么是进程、线程、协程,他们之间的关系是怎样的

    
    
    
    答案:
    进程: 本质上是一个独立执行的程序,进程是操作系统进行资源分配和调度的基本概念,操作系统进行资源分配和调度的一个独立单位
    ​
    线程:是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一个进程中可以并发多个线程,每条线程执行不同的任务,切换受系统控制。
    ​
    协程: 又称为微线程,是一种用户态的轻量级线程,协程不像线程和进程需要进行系统内核上的上下文切换,协程的上下文切换是由用户自己决定的,有自己的上下文,所以说是轻量级的线程,也称之为用户级别的线程就叫协程,一个线程可以多个协程,线程进程都是同步机制,而协程则是异步 
    Java的原生语法中并没有实现协程,目前python、Lua和GO等语言支持
    ​
    关系:一个进程可以有多个线程,它允许计算机同时运行两个或多个程序。线程是进程的最小执行单位,CPU的调度切换的是进程和线程,进程和线程多了之后调度会消耗大量的CPU,CPU上真正运行的是线程,线程可以对应多个协程
    ​
    

     

  • 协程对于多线程有什么优缺点吗

  • 难度【***】

    
    
    
    优点:
        非常快速的上下文切换,不用系统内核的上下文切换,减小开销
        单线程即可实现高并发,单核CPU可以支持上万的协程
        由于只有一个线程,也不存在同时写变量的冲突,在协程中控制共享资源不需要加锁
    缺点:
        协程无法利用多核资源,本质也是个单线程
        协程需要和进程配合才能运行在多CPU上
        目前java没成熟的第三方库,存在风险
        调试debug存在难度,不利于发现问题
    
    
    

     

 

第2集 多年开发经验的你是否可以清晰表达 并发、并行的区别

简介:是否清晰表达并发+并行的区别

  • 考点:计算机基础并发、并行概念

  • 难度【**】

  • 说下并发和并行的区别,举些例子说下

    
    
    
    并发 concurrency:
    一台处理器上同时处理任务, 这个同时实际上是交替处理多个任务,程序中可以同时拥有两个或者多个线程,当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程,它只能把CPU运行时间划分成若干个时间段,再将时间段分配给各个线程执行
    ​
    并行 parallellism:
        多个CPU上同时处理多个任务,一个CPU执行一个进程时,另一个CPU可以执行另一个进程,两个进程互不抢占CPU资源,可以同时进行
    
    并发指在一段时间内宏观上去处理多个任务。  并行指同一个时刻,多个任务确实真的同时运行。    
    ​
    例子:
    并发是一心多用,听课和看电影,但是CPU大脑只有一个,所以轮着来
    并行:火影忍者中的影分身,有多个你出现,可以分别做不同的事情
    ​
    一个项目经理A和3个程序B C D的故事
    单线程
    并发:A给B讲完需求,B自己去实现,期间A继续给C和D讲,不用等待某个程序员去完成,期间项目经理没空闲下来
    并行:直接找3个项目经理分别分配给3个程序员
    

     

第3集 新版Java多线程的实现方式你知道多少《上》

简介: Java多线程的实现方式和区别

  • 考点:java多线程基础知识

  • 难度:【***】

  • 你知道java里面实现多线程有哪几种方式,有什么不同,比较常用哪种

    • 继承Thread

    •  
      
      
      继承Thread,重写里面run方法,创建实例,执行start
      优点:代码编写最简单直接操作
      缺点:没返回值,继承一个类后,没法继承其他的类,拓展性差
      ​
      public class ThreadDemo1 extends Thread {
          @Override
          public void run() {
              System.out.println("继承Thread实现多线程,名称:"+Thread.currentThread().getName());
          }
      }
      ​
      ​
      ​
      public static void main(String[] args) {
      ​
            ThreadDemo1 threadDemo1 = new ThreadDemo1();
            threadDemo1.setName("demo1");
            threadDemo1.start();
            System.out.println("主线程名称:"+Thread.currentThread().getName());
      ​
      }

       

    • 实现Runnable

    •  
      
      
      自定义类实现Runnable,实现里面run方法,创建Thread类,使用Runnable接口的实现对象作为参数传递给Thread对象,调用Strat方法
      ​
      优点:线程类可以实现多个几接口,可以再继承一个类
      缺点:没返回值,不能直接启动,需要通过构造一个Thread实例传递进去启动
      ​
      ​
      public class ThreadDemo2 implements Runnable {
      ​
          @Override
          public void run() {
              System.out.println("通过Runnable实现多线程,名称:"+Thread.currentThread().getName());
          }
      }
      ​
      ​
      ​
      public static void main(String[] args) {
              ThreadDemo2 threadDemo2 = new ThreadDemo2();
              Thread thread = new Thread(threadDemo2);
              thread.setName("demo2");
              thread.start();
              System.out.println("主线程名称:"+Thread.currentThread().getName());
      }
      ​
      ​
      ​
      ​
      JDK8之后采用lambda表达式
      public static void main(String[] args) {
          Thread thread = new Thread(()->{
                      System.out.println("通过Runnable实现多线程,名称:"+Thread.currentThread().getName());
                  });
          thread.setName("demo2");
          thread.start();
          System.out.println("主线程名称:"+Thread.currentThread().getName());
      }
      
      
      
      
      

       

第4集 新版Java多线程的实现方式你知道多少《下》

简介: Java多线程的实现方式和区别

  • 考点:java多线程基础知识

  • 难度:【** **】

  • 你知道java里面实现多线程有哪几种方式,有什么不同,比较常用哪种

    • 通过Callable和FutureTask方式

    •  
      
      
      创建callable接口的实现类,并实现call方法,结合FutureTask类包装Callable对象,实现多线程
      优点:有返回值,拓展性也高
      缺点:jdk5以后才支持,需要重写call方法,结合多个类比如FutureTask和Thread类
      ​
      ​
      public class MyTask implements Callable {
          @Override
          public Object call() throws Exception {
      ​
              System.out.println("通过Callable实现多线程,名称:"+Thread.currentThread().getName());
      ​
              return "这是返回值";
          }
      }
      ​
       public static void main(String[] args) {
      ​
      ​
              FutureTask futureTask = new FutureTask<>(()->{
                  System.out.println("通过Callable实现多线程,名称:"+Thread.currentThread().getName());
                  return "这是返回值";
              });
      ​
      ​
      //        MyTask myTask = new MyTask();
      //        FutureTask futureTask = new FutureTask<>(myTask);
      ​
              //FutureTask继承了Runnable,可以放在Thread中启动执行
              Thread thread = new Thread(futureTask);
              thread.setName("demo3");
              thread.start();
              System.out.println("主线程名称:"+Thread.currentThread().getName());
      ​
              try {
      ​
                  System.out.println(futureTask.get());
      ​
              } catch (InterruptedException e) {
                  //阻塞等待中被中断,则抛出
                  e.printStackTrace();
              } catch (ExecutionException e) {
      ​
                  //执行过程发送异常被抛出
                  e.printStackTrace();
              }
      ​
      ​
          }
      ​
      ​
       

       

    • 通过线程池创建线程

    •  
      
      
      自定义Runnable接口,实现run方法,创建线程池,调用执行方法并传入对象
      优点:安全高性能,复用线程
      缺点: jdk5后才支持,需要结合Runnable进行使用
      ​
      ​
      public class ThreadDemo4 implements Runnable {
      ​
          @Override
          public void run() {
              System.out.println("通过线程池+runnable实现多线程,名称:"+Thread.currentThread().getName());
          }
      }
      ​
      ​
      public static void main(String[] args) {
              ExecutorService executorService = Executors.newFixedThreadPool(3);
      ​
              for(int i=0;i<10;i++){
                  executorService.execute(new ThreadDemo4());
              }
      ​
      ​
              System.out.println("主线程名称:"+Thread.currentThread().getName());
      ​
              //关闭线程池
              executorService.shutdown();
      }
      

       

      • 一般常用的Runnable 和 第四种线程池+Runnable,简单方便扩展,和高性能 (池化的思想)

       

       

       

       

       

       

      第5集 新版Java线程的状态你知道多少?

      简介:线程有几种状态有哪些,分别解释下

      • 考点:是否掌握线程常见的状态

      • 难度:【**】

      • java线程常见的基本状态有哪些,这些状态分别是做什么的

        
        
        
        JDK的线程状态分6种,JVM里面9种,我们一般说JDK的线程状态
        ​
        常见的5种状态
        ​
        创建(NEW): 生成线程对象,但是并没有调用该对象start(), new Thread()
        ​
        就绪(Runnable):当调用线程对象的start()方法,线程就进入就绪状态,但是此刻线程调度还没把该线程设置为当前线程,就是没获得CPU使用权。   如果线程运行后,从等待或者睡眠中回来之后,也会进入就绪状态
            注意:有些文档把就绪和运行两种状态统一称为 “运行中”
        ​
        运行(Running)
            程序将处于就绪状态的线程设置为当前线程,即获得CPU使用权,这个时候线程进入运行状态,开始运行run里面的逻辑
        ​
        阻塞(Blocked)
            等待阻塞:进入该状态的线程需要等待其他线程作出一定动作(通知或中断),这种状态的话CPU不会分配过来,他们需要被唤醒,可能也会无限等待下去。比如调用wait(状态就会变成WAITING状态),也可能通过调用sleep(状态就会变成TIMED_WAITING), join或者发出IO请求,阻塞结束后线程重新进入就绪状态
        
            同步阻塞:线程在获取synchronized同步锁失败,即锁被其他线程占用,它就会进入同步阻塞状态
        
            备注:相关资料会用细分下面的状态
                等待(WAITING):进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
                超时等待(TIMED_WAITING):该状态不同于WAITING,它可以在指定的时间后自行返回
        
        ​
        死亡(TERMINATED):一个线程run方法执行结束,该线程就死亡了,不能进入就绪状态
        ​
        
        
        
        
        
        
        
        
        
        
        

         

       

      第6集 新版Java线程的常见方法你知道多少?

      简介:线程有几种状态,他们转化关系是怎样的

      • 考点:常见线程的api操作是否熟悉

      • 难度:【**】

      • 是否了解多线程开发里面常用的方法,sleep/yield/join wait/notify/notifyAll, 分别解释下

        
        
        
        sleep
            属于线程Thread的方法
            让线程暂缓执行,等待预计时间之后再恢复
            交出CPU使用权,不会释放锁
            进入阻塞状态TIME_WAITGING,睡眠结束变为就绪Runnable
        
        yield
            属于线程Thread的方法
            t1/t2/t3
            暂停当前线程的对象,去执行其他线程
            交出CPU使用权,不会释放锁,和sleep类似
            作用:让相同优先级的线程轮流执行,但是不保证一定轮流
            注意:不会让线程进入阻塞状态,直接变为就绪Runnable,只需要重新获得CPU使用权
        
        
        join  
            属于线程Thread的方法
            在主线程上运行调用该方法,会让主线程休眠,不会释放已经持有的对象锁
            让调用join方法的线程先执行完毕,在执行其他线程
            类似让救护车警车优先通过
        
        wait
            属于Object的方法
            当前线程调用对象的wait方法,会释放锁,进入线程的等待队列
            需要依靠notify或者notifyAll唤醒,或者wait(timeout)时间自动唤醒
        
        notify
            属于Object的方法
            唤醒在对象监视器上等待的单个线程,选择是任意的
        
        notifyAll
            属于Object的方法
            唤醒在对象监视器上等待的全部线程
        
        
        
        
        
        
        

         

      第7集 新版Java线程的状态转换流程图你会画不

      简介:线程有几种状态和API,画出转换流程图

      • 考点:常见线程状态和API结合考查

      • 难度:【** **】

      • 看来挺熟悉多线程的,那你画下线程的状态转换图和这些转换过程常用的api也标记下

        image-20200203175236272

      第8集 新版Java并发编程核心知识点掌握多少《一》

      简介:并发编程常见知识点考查

      • 考点:并发编程常见知识点考查

      • 难度:【***】

      • 平时业务代码里面使用过多线程吗,能举例几个多线程的业务场景吗?

        
        
        
        异步任务:用户注册、记录日志
        定时任务:定期备份日志、备份数据库
        分布式计算:Hadoop处理任务mapreduce,master-wark(单机单进程)
        服务器编程:Socket网络编程,一个连接一个线程

         

      • 能举几个不是线程安全的数据结构吗?

         
        
        
        HashMap、ArrayList、LinkedList

         

      • 在Java中可以有哪些方法来保证线程安全

        
        
        
        加锁,比如synchronize/ReentrantLock
        使用volatile声明变量,轻量级同步,不能保证原子性(需要解释)
        使用线程安全类(原子类AtomicXXX,并发容器,同步容器 CopyOnWriteArrayList/ConcurrentHashMap等
        ThreadLocal本地私有变量/信号量Semaphore等
        
        
        
        
        
        
        
        
        
        
        

         

      第9集 新版Java并发编程核心知识点volatile掌握多少 《二》

      简介:并发编程常见知识点考查:volatile

      • 考点:并发编程常见知识点考查

      • 难度:【***】

      • 了解volatile关键字不?能否解释下,然后这和synchronized有什么大的区别

        
        
        
        volatile是轻量级的synchronized,保证了共享变量的可见性,被volatile关键字修饰的变量,如果值发生了变化,其他线程立刻可见,避免出现脏读现象
        ​
        volatile:保证可见性,但是不能保证原子性
        synchronized:保证可见性,也保证原子性
        ​
        使用场景
        1、不能修饰写入操作依赖当前值的变量,比如num++、num=num+1,不是原子操作,肉眼看起来是,但是JVM字节码层面不止一步
        ​
        2、由于禁止了指令重排,所以JVM相关的优化没了,效率会偏弱
        

         

       

      • 为什么会出现脏读?

        
        
        
        JAVA内存模型简称 JMM
        JMM规定所有的变量存在在主内存,每个线程有自己的工作内存,线程对变量的操作都在工作内存中进行,不能直接对主内存就行操作
        ​
        使用volatile修饰变量
        每次读取前必须从主内存属性最新的值
        每次写入需要立刻写到主内存中
        ​
        volatile关键字修修饰的变量随时看到的自己的最新值,假如线程1对变量v进行修改,那么线程2是可以马上看见

        image-20200205223949174

       

       

       

       

      第10集 新版Java并发编程 指令重排/happens-before 掌握多少《三》

      简介:并发编程常见知识点考查:指令重排、happens-before

      • 考点:并发编程常见知识点考查

      • 难度:【***】

      • 你说volatile可以避免指令重排,能否解释下什么是指令重排

        
        
        
        指令重排序分两类 编译器重排序和运行时重排序
        ​
        JVM在编译java代码或者CPU执行JVM字节码时,对现有的指令进行重新排序,主要目的是优化运行效率(不改变程序结果的前提)
        ​
        int a = 3 //1
        int b = 4 //2
        int c =5 //3 
        int h = a*b*c //4
        ​
        定义顺序 1,2,3,4
        计算顺序  1,3,2,4 和 2,1,3,4 结果都是一样
        ​
        ​
        虽然指令重排序可以提高执行效率,但是多线程上可能会影响结果,有什么解决办法?
        解决办法:内存屏障
        解释:内存屏障是屏障指令,使CPU对屏障指令之前和之后的内存操作执行结果的一种约束
        ​
        
        
        

         

      • 知道 happens-before吗,能否简单解释下?

        
        
        
        先行发生原则,volatile的内存可见性就提现了该原则之一
        ​
        ​
        例子:
        //线程A操作
        int k = 1;
        ​
        //线程B操作
        int j = k;
        ​
        //线程C操作
        int k = 2
        ​
        分析:
        假设线程A中的操作“k=1”先行发生于线程B的操作“j=k”,那确定在线程B的操作执行后,变量j的值一定等于1,依据有两个:一是先行发生原则,“k=1”的结果可以被观察到;二是第三者线程C还没出现,线程A操作结束之后没有其他线程会修改变量k的值。
        ​
        但是考虑线程C出现了,保持线程A和线程B之间的先行发生关系,线程C出现在线程A和线程B的操作之间,但是线程C与线程B没有先行发生关系,那j的值会是多少?答案是1和2都有可能,因为线程C对变量k的影响可能会被线程B观察到,也可能不会,所以线程B就存在读取到不符合预期数据的风险,不具备多线程安全性
        ​
        ​
        八大原则(对这个不理解,一定要去补充相关博文知识)
        1、程序次序规则
        2、管程锁定规则
        3、volatile变量规则
        4、线程启动规则
        5、线程中断规则
        6、线程终止规则
        7、对象终结规则
        8、传递性

        ​干货文档

       

      你可能感兴趣的:(视频教程,面试,并发编程,多线程,java,面试,编程语言,后端)