多线程

多线程

1、线程相关

1）并行和并发的区别？

  • 并行：多个处理器或多核处理器同时处理多个任务。
  • 并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。

2）线程和进程的区别？

一个程序下至少有一个进程，一个进程下至少有一个线程，一个进程下也可以有多个线程来增加程序的执行速度。


3）守护线程是什么？

守护线程是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。在 Java 中垃圾回收线程就是特殊的守护线程。


4）创建线程的方式？

  • 继承 Thread 重写 run 方法；
  • 实现 Runnable 接口，重写run方法（推荐：可以避免单继承局限） 无返回值；
  • 实现 Callable 接口，重写call方法，有返回值；
  • 通过线程池创建；

5）线程的状态？

  • NEW 新建
  • RUNNABLE 就绪（ready）和运行中（running）两种状态笼统的称为“运行”
  • BLOCKED 阻塞
  • TERMINATED 死亡
  • WAITING 永久等待状态
  • TIMED_WAITING 等待指定的时间重新被唤醒的状态

6）sleep() 和 wait() 有什么区别？

  • 类的不同：sleep() 来自 Thread，wait() 来自 Object。
  • 释放锁：sleep() 不释放锁；wait() 释放锁。
  • 用法不同：sleep() 时间到会自动恢复；wait() 可以使用 notify()/notifyAll()直接唤醒。

7）notify()和 notifyAll()有什么区别？

notifyAll()会唤醒所有的线程，notify()之后唤醒一个线程。notifyAll() 调用后，会将全部线程由等待池移到锁池，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池等待锁被释放后再次参与竞争。而 notify()只会唤醒一个线程，具体唤醒哪一个线程由虚拟机控制。


8）线程的 run() 和 start() 有什么区别？

start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。run() 可以重复调用，而 start() 只能调用一次。



2、线程池相关

1）什么是线程池？为什么要使用它？

创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变长，而且一个进程能创建的线程数有限。

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。
假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。

如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。


2）创建线程池的方式？

线程池创建有七种方式，最核心的是最后一种：

  • newSingleThreadExecutor()：单工作线程池 它的特点在于工作线程数目被限制为 1，操作一个无界的工作队列，所以它保证了所有任务的都是被顺序执行，最多会有一个任务处于活动状态，并且不允许使用者改动线程池实例，因此可以避免其改变线程数目；
  • newCachedThreadPool()： 可缓存的线程池 它是一种用来处理大量短时间工作任务的线程池，具有几个鲜明特点：它会试图缓存线程并重用，当无缓存线程可用时，就会创建新的工作线程；如果线程闲置的时间超过 60 秒，则被终止并移出缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用 SynchronousQueue 作为工作队列；
  • newFixedThreadPool(int nThreads)： 定长线程池 重用指定数目（nThreads）的线程，其背后使用的是无界的工作队列，任何时候最多有 nThreads 个工作线程是活动的。这意味着，如果任务数量超过了活动队列数目，将在工作队列中等待空闲线程出现；如果有工作线程退出，将会有新的工作线程被创建，以补足指定的数目 nThreads；
  • newSingleThreadScheduledExecutor()：创建单线程池，返回 ScheduledExecutorService，可以进行定时或周期性的工作调度；
  • newScheduledThreadPool(int corePoolSize)：和newSingleThreadScheduledExecutor()类似，创建的是个 ScheduledExecutorService，可以进行定时或周期性的工作调度，区别在于单一工作线程还是多个工作线程；
  • newWorkStealingPool(int parallelism)：这是一个经常被人忽略的线程池，Java 8 才加入这个创建方法，其内部会构建ForkJoinPool，利用Work-Stealing算法，并行地处理任务，不保证处理顺序；
  • ThreadPoolExecutor()：是最原始的线程池创建，上面1-3创建方式都是对ThreadPoolExecutor的封装。

3）线程池的状态？

  • RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。
  • SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务。
  • STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程。
  • TIDYING：所有的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()。
  • TERMINATED：terminated()方法结束后，线程池的状态就会变成这个。

4）线程池中 submit() 和 execute() 方法有什么区别？

  • execute()：只能执行 Runnable 类型的任务。
  • submit()： 可以执行 Runnable 和 Callable 类型的任务。

5）线程池的7个参数？

public ThreadPoolExecutor(
int corePoolSize, //线程池核心线程大小                          
int maximumPoolSize, //线程池最大线程数量                         
long keepAliveTime, //空闲线程存活时间                         
TimeUnit unit, //keepAliveTime的计量单位                          
BlockingQueue<Runnable> workQueue, //工作队列                         
ThreadFactory threadFactory, //设置创建线程的工厂                          
RejectedExecutionHandler handler //拒绝策略
)

  • corePollSize

    • 核心池大小，默认情况下，在创建了线程之后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePollSize后，就会把到达的任务放到缓存队列当中。也可以通过prestartCoreThread() 或者 prestartAllCoreThreads 在任务还没到达的情况下，预先创建线程。

  • maximumPoolSize

    • 线程池最大线程数，表示线程池中能创建的最大线程数

  • keepAliveTime

    • 表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，知道线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到了keepAliveTime，则会终止。但是如果调用了allowCoreThreadTimeOut(boolean) 方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，知道线程池中的线程数为0

  • unit

    • 参数 keepAliveTime 的时间单位
    TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

  • workQueue

    • 一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
      • ArrayBlockingQueue
      • LinkedBlockingQueue
      • SynchronouseQueue
      • ProorityBlockingQueue
    • 一般使用LinkedBlockingQueue和synchronousQueue，线程池的排队策略与BlockingQueue有关

  • threadFactory

    • 用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程做些有意义的事情，比如设置deamon和 优先级等等

  • handler

    • 表示当拒绝处理任务时的策略

      AbortPolicy：直接抛出异常。
DiscardPolicy：不处理，丢弃掉。
CallerRunsPolicy：只用调用者所在线程来运行任务。
DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。

6）线程池的线程数如何设计？

CPU密集型（计算为主）：【cpu核心数】【cpu核心数+1】【cpu核心数-1】。
IO密集型（磁盘或网络为主）：【cpu核心数*2】。
混合型：【cpu核心数 / (1 - 阻塞系数)】，阻塞系数=阻塞时间/(阻塞时间+计算时间)。
求并发：【并发数=线程数/单个任务时间】。

首先，考虑线程池究竟需要几个呢？不同业务是否需要不同线程池来避免某个业务阻塞时，其他业务也无法运行。最好是业务分类，不同的线程池去执行。

N-1原因：然后，每个线程池的线程数量，要考虑业务上下游，cpu，io资源使用的情况，来设计。很多线程池设计为cpu核数-1，例如Java 8之后jvm启动时默认会启动的coomonForkJoinPool，这个线程池执行forkjointask，高峰时很容易吃满cpu，属于计算密集型，这个情况下，最好设置为cpu核数-1，避免出问题时吃满cpu，导致其他业务完全无法运行，并且无法恢复以及定位问题。还有很多线程池设置为cpu核数*2，这是考虑IO是阻塞有延迟的，属于IO密集型，这样在IO阻塞，并且请求到达之间有延迟，每个线程都能充分运用。还要考虑业务上下游，例如上游业务线程池个数，下游业务线程池个数，还有就是本身能使用的IO资源，例如数据库连接个数等等。

N+1原因：计算密集型的线程恰好在某时因为发生一个页错误或者因其他原因而暂停，刚好有一个“额外”的线程，可以确保在这种情况下CPU周期不会中断工作。所以N+1确实是一个经验值。



3、并发编程

1）并发编程中的三个概念？

  • 原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

  • 可见性：是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

  • 有序性：即程序执行的顺序按照代码的先后顺序执行


2）CAS

CAS是compare and swap的缩写，即我们所说的比较交换。cas是一种基于锁的操作，而且是乐观锁。在java中锁分为乐观锁和悲观锁。

  • 悲观锁是将资源锁住，等一个之前获得锁的线程释放锁之后，下一个线程才可以访问。
  • 乐观锁采取了一种宽泛的态度，通过某种方式不加锁来处理资源，比如通过给记录加version来获取数据，性能较悲观锁有很大的提高。

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存地址里面的值和A的值是一样的，那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的，若果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能机会执行。


3）volatile

volatile到底如何保证可见性和禁止指令重排序的。

　　下面这段话摘自《深入理解Java虚拟机》：

　　“观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”

　　lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

　　1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

　　2）它会强制将对缓存的修改操作立即写入主存；

　　3）如果是写操作，它会导致其他CPU中对应的缓存行无效。


4）java对象

在JVM中，对象在内存中的布局分为三块区域：对象头、实例数据和对齐填充。如下图所示：

  1. 实例数据：存放类的属性数据信息，包括父类的属性信息；
  2. 对齐填充：由于虚拟机要求 对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐；
  3. 对象头：Java对象头一般占有2个机器码（在32位虚拟机中，1个机器码等于4字节，也就是32bit，在64位虚拟机中，1个机器码是8个字节，也就是64bit），但是 如果对象是数组类型，则需要3个机器码，因为JVM虚拟机可以通过Java对象的元数据信息确定Java对象的大小，但是无法从数组的元数据来确认数组的大小，所以用一块来记录数组长度。

Synchronized用的锁就是存在Java对象头里的，那么什么是Java对象头呢？Hotspot虚拟机的对象头主要包括两部分数据：Mark Word（标记字段）、Class Pointer（类型指针）。其中 Class Pointer是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例，Mark Word用于存储对象自身的运行时数据，它是实现轻量级锁和偏向锁的关键。 Java对象头具体结构描述如下：

Java对象头结构组成

Mark Word用于存储对象自身的运行时数据，如：哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程 ID、偏向时间戳等。比如锁膨胀就是借助Mark Word的偏向的线程ID 参考：JAVA锁的膨胀过程和优化(阿里) 阿里也经常问的问题

下图是Java对象头 无锁状态下Mark Word部分的存储结构（32位虚拟机）：

Mark Word存储结构

对象头信息是与对象自身定义的数据无关的额外存储成本，但是考虑到虚拟机的空间效率，Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据，它会根据对象的状态复用自己的存储空间，也就是说，Mark Word会随着程序的运行发生变化，可能变化为存储以下4种数据：

Mark Word可能存储4种数据

在64位虚拟机下，Mark Word是64bit大小的，其存储结构如下：

64位Mark Word存储结构

对象头的最后两位存储了锁的标志位，01是初始状态，未加锁，其对象头里存储的是对象本身的哈希码，随着锁级别的不同，对象头里会存储不同的内容。偏向锁存储的是当前占用此对象的线程ID；而轻量级则存储指向线程栈中锁记录的指针。从这里我们可以看到，“锁”这个东西，可能是个锁记录+对象头里的引用指针（判断线程是否拥有锁时将线程的锁记录地址和对象头里的指针地址比较)，也可能是对象头里的线程ID（判断线程是否拥有锁时将线程的ID和对象头里存储的线程ID比较）。


5）synchronized

synchronized 特性

  • 可重入
    • 一个线程已经获得这个锁，再次尝试获取锁也可以获得，计数器会加一
  • 不可中断
    • 一个线程访问代码块时发现锁已经被其他线程获取，就会一直处于阻塞状态，这个过程不会被中断

synchronized 实现原理：

synchronized 是由一对 monitorenter/monitorexit 指令实现的，monitor 对象是同步的基本实现单元。在 Java 6 之前，monitor 的实现完全是依靠操作系统内部的互斥锁，因为需要进行用户态到内核态的切换，所以同步操作是一个无差别的重量级操作，性能也很低。

Java 6 synchronized 锁升级原理：在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候 threadid 为空，jvm 让其持有偏向锁，并将 threadid 设置为其线程 id，再次进入的时候会先判断 threadid 是否与其线程 id 一致，如果一致则可以直接使用此对象，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁，执行一定次数之后，如果还没有正常获取到要使用的对象，此时就会把锁从轻量级升级为重量级锁，此过程就构成了 synchronized 锁的升级。

synchronized 是可以自动释放锁的，如果发生异常，会自动释放锁。

synchronized 锁升级机制：

  • 偏向锁
    • 使用场景：单线程环境
    • 对象头会保存线程id，偏向锁标识为1，锁标识位为01
    • 锁释放：存在锁竞争，达到全局安全点
  • 轻量级锁
    • 使用场景：多线程交替执行同一个同步代码块
    • 栈帧中创建Lock Record，保存对象头的hashcode、分代年龄、锁标识。owner里保存锁对象的地址。对象头将锁标识改为00，mark word中保存Lock Word的地址。
  • 重量级锁
    • 通过对象内部的一个叫做监视器锁（Monitor）来实现。

6）synchronized、lock、volitale 的区别？

synchronized 与 lock 的区别？

  • synchronized 是 关键字， 而lock 是接口

  • synchronized 可以修饰代码块和方法，而lock 只能修饰代码块

  • synchronized 不能被中断，而lock 可以被中断（trylock()），也可以不被中断（lock()）

  • synchronized 可以自动释放锁，而lock 只能手动释放锁

  • synchronized 是 安全的，lock 可以设置是不是安全的 （等待的线程获取锁如果是先来先获取则是安全的）

  • 通过lock 可以知道是否成功拿到锁，而 syncronized不能

  • lock 可以通过读锁提高多线程读的效率

synchronized 和 volatile 的区别？

  • volatile 是变量修饰符；synchronized 是修饰类、方法、代码段。

  • volatile 仅能实现变量的修改可见性，不能保证原子性；而 synchronized 则可以保证变量的修改可见性、原子性、有序性。

  • volatile 不会造成线程的阻塞；synchronized 可能会造成线程的阻塞。

posted @ 2021-07-22 16:49  随性0528  阅读(67)  评论(0)    收藏  举报