丙丙-2个月面试20家大厂的知识点总结和建议（答案）

面试问题汇总
基础问题

linux和网络基础

（1）linux系统内核态和用户态是什么，有什么区别？

当程序运行在3级特权级上时，就可以称之为运行在用户态，因为这是最低特权级，是普通的用户进程运行的特权级，大部分用户直接面对的程序都是运行在用户态；反之，当程序运行在0级特权级上时，就可以称之为运行在内核态。

虽然用户态下和内核态下工作的程序有很多差别，但最重要的差别就在于特权级的不同，即权力的不同。运行在用户态下的程序不能直接访问操作系统内核数据结构和程序，比如上面例子中的testfork()就不能直接调用sys_fork()，因为前者是工作在用户态，属于用户态程序，而sys_fork()是工作在内核态，属于内核态程序。

当我们在系统中执行一个程序时，大部分时间是运行在用户态下的，在其需要操作系统帮助完成某些它没有权力和能力完成的工作时就会切换到内核态。

（2）BIO、NIO、AIO都是什么，有什么区别？

• BIO (Blocking I/O): BIO，同步阻塞IO，阻塞整个步骤，如果连接少，他的延迟是最低的，因为一个线程只处理一个连接，适用于少连接且延迟低的场景，比如说数据库连接。

• NIO (New I/O):同步非阻塞IO，阻塞业务处理但不阻塞数据接收，适用于高并发且处理简单的场景，比如聊天软件。

• AIO (Asynchronous I/O): AIO 也就是 NIO 2，异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。

• 多路复用IO，他的两个步骤处理是分开的，也就是说，一个连接可能他的数据接收是线程a完成的，数据处理是线程b完成的，他比BIO能处理更多请求。

• 信号驱动IO，这种IO模型主要用在嵌入式开发，不参与讨论。

• 异步IO，他的数据请求和数据处理都是异步的，数据请求一次返回一次，适用于长连接的业务场景。

（3）TCP和UDP的区别？

（4）详细叙述TCP3次握手，TCP和HTTP的区别，其中字节面试官问的最细，他会具体问TCP底层的3次握手的具体实现逻辑，第三次握手如果失败会怎样。

建议把TCP关闭时的4次挥手也看看，敖丙的文章就有，看了至少表面的东西难不倒你们，由于这个是最基础的问题，如果回答不好，面试官的印象分就你懂得。

（5）rpc和http的区别，你知道有什么rpc框架。

http请求是使用具有标准语义的通用的接口定向到资源的，这些语义能够被中间组件和提供服务的来源机器进行解释。rpc的机制是根据语言的API(language API)来定义的，而不是根据基于网络的应用来定义的。
Spring Cloud、Dubbo

（6）https相对http都实现了什么加密方式，是对称加密还是非对称加密？

HTTPS结合对称加密+非对称加密这两种方式，我们可以用非对称加密的方式来传输对称加密过程中的密钥，之后我们就可以采取对称加密的方式来传输数据了。具体是这样子的：

服务器用明文的方式给客户端发送自己的公钥(CA会把公钥以及服务器的个人信息通过Hash算法生成信息摘要)，客户端收到公钥之后，会生成一把密钥(对称加密用的)，然后用服务器的公钥对这把密钥进行加密，之后再把密钥传输给服务器，服务器收到之后进行解密，最后服务器就可以安全得到这把密钥了，而客户端也有同样一把密钥，他们就可以进行对称加密了。

（7）用linux命令怎么做分组求和，怎么把字符串根据分隔符变成数组（这里建议大家读读敖丙的linux命令篇）

JVM基础

（1）简要介绍一下JVM虚拟机（这个问题不是把JVM分成JMM，类加载和GC来问，一定要想好怎么描述JVM）

（2）简述一次GC的过程（Minor gc和Major gc过程还记得么）

（3）JMM是什么？

Java虚拟机是一个实现了跨平台的虚拟系统，因此它也有自己的内存模型，即Java内存模型（Java Memory Model, JMM）.
线程之间的共享变量存储在主内存（Main Memory）中，每个线程都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化。

（4）JVM共享内存都有什么，什么是堆外内存？

堆外内存就是把内存对象分配在Java虚拟机堆以外的内存，这些内存直接受操作系统管理（而不是虚拟机），这样做的结果就是能够在一定程度上减少垃圾回收对应用程序造成的影响。使用堆外内存了，JVM也希望能在合适的时候自动的对堆外内存进行回收。

（5）GC区域，垃圾回收算法，垃圾回收器，G1、CMS、ParNew等垃圾回收器的简介和之间的区别。

（6）类加载过程（5个过程最好能研究明白，因为还涉及到栈帧、局部表量表、操作数栈、动态链接和方法出口等知识，去看一下敖丙的文章就明白了）

jvm之java类加载机制和类加载器(ClassLoader)的详解

（7）一个ArrayList的两个对象的getClass()得到的结果相同么（理解类加载和Class类类型）

（8）死锁怎么查问题（-XX:+PrintGCDetails）

• 使用 jps + jstack
• 使用jconsole(图形化的监控工具)
• Java Visual VM(图形化的监控工具)

死锁怎么查

（9）Gc日志得会看，尤其问到怎么查OOM问题的时候，你应该知道使用jconsole，jstat，jmap，jvisualvm等的工具来查看gc状态，看看是不是年轻代设置太小了导致major gc频繁或者内存泄露了。

JAVA基础和多线程基础

（1）synchronized在JDK6做了哪些优化，synchronized和lock的区别

1. 适应自旋锁
      自旋锁：为了减少线程状态改变带来的消耗 不停地执行当前线程
2. 锁消除：
     不可能存在共享数据竞争的锁进行消除
3. 锁粗化：
     将连续的加锁 精简到只加一次锁
4. 轻量级锁：
    无竞争条件下 通过CAS消除同步互斥
5. 偏向锁：
   无竞争条件下 消除整个同步互斥，连CAS都不操作。

• Synchronized是关键字，内置语言实现，Lock是接口。
• Synchronized在线程发生异常时会自动释放锁，因此不会发生异常死锁。Lock异常时不会自动释放锁，所以需要在finally中实现释放锁。
• Lock是可以中断锁，Synchronized是非中断锁，必须等待线程执行完成释放锁。
• Lock可以使用读锁提高多线程读效率。

synchronized和lock的区别

（2）懒汉单例用duble check是线程安全的么，为什么要加volatile

private volatile static Singleton uniqueInstance;
这段代码其实是分为三步执行：

• 为 uniqueInstance 分配内存空间
• 初始化 uniqueInstance
• 将 uniqueInstance 指向分配的内存地址

但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。

使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

（3）Volatile有什么用，什么是CAS

CAS：Compare and Swap，即比较再交换。AtomicInteger.incrementAndGet()使用到了

对CAS的理解，CAS是一种无锁算法，CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。(CAS 操作是基于共享数据不会被修改的假设-乐观锁)

CAS（比较并交换）是CPU指令级的操作，只有一步原子操作，所以非常快。而且CAS避免了请求操作系统来裁定锁的问题，不用麻烦操作系统，直接在CPU内部就搞定了。

（4）什么是happens before原则

因为jvm会对代码进行编译优化，指令会出现重排序的情况，为了避免编译优化对并发编程安全性的影响，需要happens-before规则定义一些禁止编译优化的场景，保证并发编程的正确性。

• 规则一：程序的顺序性规则（一个线程中，按照程序的顺序，前面的操作happens-before后续的任何操作。）
• 规则二：volatile规则（对一个volatile变量的写操作，happens-before后续对这个变量的读操作。）
• 规则三：传递性规则（如果A happens-before B，B happens-before C，那么A happens-before C。）
• 规则四：管程中的锁规则（对一个锁的解锁操作，happens-before后续对这个锁的加锁操作。）
• 规则五：线程start()规则（主线程A启动线程B，线程B中可以看到主线程启动B之前的操作。也就是start() happens before 线程B中的操作。）
• .规则六：线程join()规则（主线程A等待子线程B完成，当子线程B执行完毕后，主线程A可以看到线程B的所有操作。也就是说，子线程B中的任意操作，happens-before join()的返回。）

（5）什么是AQS

AQS的核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并将共享资源设置为锁定状态，如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。
CLH（Craig，Landin，and Hagersten）队列是一个虚拟的双向队列，虚拟的双向队列即不存在队列实例，仅存在节点之间的关联关系。

AQS就是基于CLH队列，用volatile修饰共享变量state，线程通过CAS去改变状态符，成功则获取锁成功，失败则进入等待队列，等待被唤醒。

** 注意：AQS是自旋锁：**在等待唤醒的时候，经常会使用自旋（while(!cas())）的方式，不停地尝试获取锁，直到被其他线程获取成功

实现了AQS的锁有：自旋锁、互斥锁、读锁写锁、条件产量、信号量、栅栏都是AQS的衍生物。

AQS底层使用了模板方法模式
同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：

• 使用者继承AbstractQueuedSynchronizer并重写指定的方法。（这些重写方法很简单，无非是对于共享资源state的获取和释放）
• 将AQS组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。
  这和我们以往通过实现接口的方式有很大区别，这是模板方法模式很经典的一个运用。

https://www.cnblogs.com/waterystone/p/4920797.html

（6）线程sleep和wait的区别，线程join是什么意思

sleep()

1. 属于Thread类，表示让一个线程进入睡眠状态，等待一定的时间之后，自动醒来进入到可运行状态，不会马上进入运行状态
2. sleep方法没有释放锁
3. sleep必须捕获异常
4. sleep可以在 任何地方使用

wait()

1. 属于Object，一旦一个对象调用了wait方法，必须要采用notify()和notifyAll()方法唤醒该进程
2. wait方法释放了锁
3. wait不需要捕获异常
4. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用

sleep(1000)和wait(1000)的区别：
Thread.Sleep(1000) 意思是在未来的1000毫秒内本线程不参与CPU竞争，1000毫秒过去之后，这时候也许另外一个线程正在使用CPU，那么这时候操作系统是不会重新分配CPU的，直到那个线程挂起或结束，即使这个时候恰巧轮到操作系统进行CPU 分配，那么当前线程也不一定就是总优先级最高的那个，CPU还是可能被其他线程抢占去。

wait(1000)表示将锁释放1000毫秒，到时间后如果锁没有被其他线程占用，则再次得到锁，然后wait方法结束，执行后面的代码，如果锁被其他线程占用，则等待其他线程释放锁。注意，设置了超时时间的wait方法一旦过了超时时间，并不需要其他线程执行notify也能自动解除阻塞，但是如果没设置超时时间的wait方法必须等待其他线程执行notify。

join方法其实就是阻塞当前调用它的线程，等待join执行完毕，当前线程继续执行。

（7）Java都有哪几种锁（敖丙的文章）

• 公平锁/非公平锁
  公平锁是指多个线程按照申请锁的顺序来获取锁。
  非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。
  对于Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。
  对于Synchronized而言，也是一种非公平锁。由于其并不像ReentrantLock是通过AQS的来实现线程调度，所以并没有任何办法使其变成公平锁。
• 可重入锁
  可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例。
  对于Java ReentrantLock而言, 他的名字就可以看出是一个可重入锁，其名字是Re entrant Lock重新进入锁。
  对于Synchronized而言,也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。

synchronized void setA() throws Exception{
    Thread.sleep(1000);
    setB();
}

synchronized void setB() throws Exception{
    Thread.sleep(1000);
}
上面的代码就是一个可重入锁的一个特点，如果不是可重入锁的话，
setB可能不会被当前线程执行，可能造成死锁。

• 独享锁/共享锁
  独享锁是指该锁一次只能被一个线程所持有。
  共享锁是指该锁可被多个线程所持有。

对于Java ReentrantLock而言，其是独享锁。但是对于Lock的另一个实现类ReadWriteLock，其读锁是共享锁，其写锁是独享锁。
读锁的共享锁可保证并发读是非常高效的，读写，写读 ，写写的过程是互斥的。
独享锁与共享锁也是通过AQS来实现的，通过实现不同的方法，来实现独享或者共享。
对于Synchronized而言，当然是独享锁。

• 互斥锁/读写锁
  上面讲的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。
  互斥锁在Java中的具体实现就是ReentrantLock
  读写锁在Java中的具体实现就是ReadWriteLock

• 乐观锁/悲观锁
  乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。
  悲观锁认为对于同一个数据的并发操作，一定是会发生修改的，哪怕没有修改，也会认为修改。因此对于同一个数据的并发操作，悲观锁采取加锁的形式。悲观的认为，不加锁的并发操作一定会出问题。
  乐观锁则认为对于同一个数据的并发操作，是不会发生修改的。在更新数据的时候，会采用尝试更新，不断重新的方式更新数据。乐观的认为，不加锁的并发操作是没有事情的。
  悲观锁在Java中的使用，就是利用各种锁。
  乐观锁在Java中的使用，是无锁编程，常常采用的是CAS算法，典型的例子就是原子类，通过CAS自旋实现原子操作的更新。

• 分段锁
  分段锁其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。
  我们以ConcurrentHashMap来说一下分段锁的含义以及设计思想，ConcurrentHashMap中的分段锁称为Segment，它即类似于HashMap（JDK7与JDK8中HashMap的实现）的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表；同时又是一个ReentrantLock（Segment继承了ReentrantLock)。
  当需要put元素的时候，并不是对整个hashmap进行加锁，而是先通过hashcode来知道他要放在那一个分段中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在一个分段中，就实现了真正的并行的插入。
  但是，在统计size的时候，可就是获取hashmap全局信息的时候，就需要获取所有的分段锁才能统计。
  分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。

• 偏向锁/轻量级锁/重量级锁
  这三种锁是指锁的状态，并且是针对Synchronized。在Java 5通过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。
  偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。
  轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。
  重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。

• 自旋锁
  在Java中，自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

（8）线程池分几种类型，其中的coreSize、maxSize、存活时间、等待队列、拒绝策略要清楚

（9）Java乐观锁的实现（CAS+自旋）

（10）阻塞队列的实现，至少自己会实现2种阻塞队列的方法（单锁，多锁， ReentrantLock， Condition）

（11）CountDownLatch、CyclicBarrier、Semaphore区别，使用场景

（12）HashMap是线程安全的么，底层怎么实现的（get，set，resize），JDK1.8之前和之后做了哪些修改，如果要使得插入kv有序需要使用哪种HashMap（LinkedHashMap，TreeMap），ConcurrentHashMap线程安全是怎么实现的（JDK1.8前后实现不同）

（13）ArrayList和LinkedList的区别，栈和队列的区别。Queue和Deque区别

（14）Netty，Jetty实现原理。

（15）Java 静态代理、动态代理

（16）Forkjoin模型

（17）Java回调

（18）协程和线程的区别

（19）JDK1.8有什么新特性，了解函数式编程么（不了解的看看guava）

数据结构算法和设计模式

（1）设计模式一般引申自项目或者工具底层实现，所以需要懂一些比较常见的设计模式，工厂、单例、观察者、命令、适配器、代理等等

（2）算法主要是查找和排序，所以至少要会手写主流的排序算法和查找算法

（3）LSM树是怎么实现的。和mysql的B+树有什么区别（LSM树是hbase和levelDB的底层存储的结构，不懂不应该）

（4）二叉树，平衡查找二叉树，红黑树等

（5）栈，数组，链表，队列，双端队列，跳跃表（redis zset）等

spring系列

（1）AOP，IOC概念

（2）Spring cloud组件介绍，具体问的比较多的是hytrix和eureka，hytrix主要问怎么实现限流和降级（线程池和信号量），两种实现方式有什么区别，具体熔断时的配置；eureka主要介绍和zookeeper的区别，以及注册流程

（3）Spring boot配置很多都注解化了，所以常用的注解要知道

（4）过滤器和Spring拦截器的区别

消息中间件AMQP

看敖丙的文章就够了

redis缓存相关

看敖丙的文章就够了

其他类型

（1）单点登录系统怎么做（SSO系统）

（2）为什么选择cassandra而不是hbase，两者有什么区别

大数据问题
hadoop
（1）hadoop1.0的进程都有哪些，hdfs和mapreduce简介

（2）集群初始化的时候namenode都做了哪些工作，fsimage和editslog都是什么

（3）SecondaryNamenode有什么作用。

（4）Hadoop读文件和写文件流程

（5）Mapreduce过程简介（注意这个是基础，不会说拉低印象分），shuffle流程，jobclient提交job的流程等。

（6）Mapreduce怎么进行序列化反序列化的（inputFormat，outputFormat）

（7）Jobtracker都有哪些任务调度器

（8）Hadoop YARN都做了哪些优化，YARN都有哪些进程，YARN提交job的流程

（9）Mapreduce优化（mapjoin，combiner，小文件合并等）

（10）简述hive表join怎么用mapreduce实现，mapreduce二次排序，二次排序分区和分组的区别

（11）Hadoop集群HA实现（zookeeper实现主备和federation最好都弄懂概念）

（12）其他框架比如spark怎么和yarn集成的

（13）Spark相比mapreduce的优化（内存计算，RDD等）

（14）给你100亿条数据的用户表和一块100MB内存，怎么去重或者判断一个用户在不在其中（bitmap，布隆过滤器等）

（15）加分项：读过hadoop源码么，具体哪一段源码介绍一下。

hive
（1） Hive数据仓库的架构

（2） Hive怎么把sql转化成mapreduce的（至少知道sql解析器解析成AST语法树，后面解析成queryblock，进执行队列等等）

（3） Hive基本数据类型，组合类型（当时问Hive中的int类型有几种，蒙了）

（4） Hive底层存储类型，压缩格式

（5） Hive UDF，UDTF，UDAF，窗口函数（row_number, rank,cube,rollup,lag,lead）（一般是跟着sql coding来问的）

（6） Hive优化（count(distinct xxx),去除null值，小文件合并，map和reduce个数优化，解决数据倾斜）

（7） Hive分区和分桶的区别。分桶主要解决什么问题。内部表和外部表的区别。怎么动态分区。

（8） Hive怎么自动补全分区（MSCK命令，这个比较冷僻，知道有这个东西就行了）

（9） HIve列存储，rcfile和orcfile和parquet怎么存数据的

hbase
（1）hbase架构简介

（2）Hbase怎么读写数据详细流程

（3）Hbase的应用场景

（4）Hbase优化（热点，预分区，rowKey设计，手动合并等）

（5）Hbase为什么写快读慢（LSM树）

（6）Hbase是cp还是ap架构？（CAP理论看懂没有，hbase是CP的）

（7）Hbase 怎么scan数据的。

kafka
为什么kafka放到大数据里来说，因为kafka大部分场景下是ETL流程和流式计算流程的source端

（1）kafka架构简介

（2）Kafka为什么快，性能好，吞吐量大（mmap和sendfile了解一下）

（3）Kafka会丢数据么，kafka消息有序么

（4）Kafka producer consumer怎么实现at most once和exactly once（幂等计算和事务）

（5）Kafka 高可用怎么实现的（AR，ISR，OSR）。会不会脑裂（不会啊，参照zookeeper选举）

（6）Kafka leo（log end offset）和hw（high watermark）

（7）Kafka consumer消费topic的某一个partition时，不同group和同group中的消费者有什么不同。

（8）Kafka ack有几种，每种什么意思

（9）Kafka有什么坑，怎么改进（大脑风暴了）

（10）Kafka相比rabbitMq等传统消息队列有什么区别

zookeeper

（1）zookeeper简介

（2）Zookeeper节点类型

（3）Zookeeper watcher机制

（4）Zookeeper使用场景，怎么用zk设计主备高可用，怎么用zk实现分布式锁（看敖丙文章去，其实就是临时顺序znode的建立和watcher机制的妙用）

（5）Zookeeper选举机制，会不会脑裂

Coding
这里只给大家提供一些遇到过的简单问题，大家应该掌握基本的查找算法、排序算法，熟练使用递归、贪心，能明白动态规划更好。

Leetcode上面的题有空再去刷，因为几千道题要花费大量的时间，对于需要准备考sql的同学，建议把牛客网上面数据库SQL实战都做一遍，理解了就差不多了。

（1）实现一个函数把两个有序的int数组结合成新的有序数组（java，遇到过2次）

（2）给a[n]数组进行全排序，找到一个组合的前一个组合，比如a[3]{[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]}，给出[2,3,1,]，找到他的前序是[2,1,3]（java）

（3）给定一个正数数组arr（即数组元素全是正数），找出该数组中，两个元素相减的最大值，其中被减数的下标不小于减数的下标。即求出： maxValue = max{arr[j]-arr[i] and j >= i} （java）

（4）有8个球，其中有一个比其他7个重。给你一个天平要求2次称重就把重的那个球找出来。（智力题）

（5）求一个数组中不存在的最小正整数（java，这个好像是程序员面试指南里头的题）

（6）给定用户登录表，怎么查连续3天未登录的用户（sql）

（7）给定每天收入明细数据，怎么查每一天的历史收入总和（sql）

（8）Hive 表中有重复值，怎么查一共有多少个重复值（hql）

（9）给定注册表和登录表，用一个sql求1-7天留存（sql）

（10）实现拉链表（hql）

（11）给定电商订单表，字段为订单id（order_id）和订单组合（type_list），求这个订单组合中每种类型商品的相关商品TOP10,即求这个商品相关的商品（下单这个商品的同时也下单其他商品）下单量TOP10（hql，行转列）

（12）给定一个广告投放表ad,字段有aid（广告id）和citys（投放城市city_id集合）和城市表city_info,字段有city_id和city_name（城市名称），求具体城市名称的投放广告量TOP10。（hql，行转列）