【offerMe--面经必备】---腾讯面经分享（包含答案）

2024-04-02 20:54:49

1.序

马上春招了，分享一波干货。腾讯、百度、阿里、京东、快手、斗鱼、华为、海康威视等面试过程。昨天分享了快手，今天来看看腾讯。

在面试之前给大家看看我的简历以及个人简介部分，因为面试过程与自己的简历有很大关系。面试官往往会结合简历以及个人简介来问。

个人简历：梦想成真-----项目自我介绍

个人简介：【offerMe–简介必备】一字一句教你面试“个人简介”

2.腾讯面试过程

2.1腾讯1面（部门：WXG、时间：120分钟）

题目算法
旋转数字的最小数字（注意（1,0,1,1,1））这种情况
合并两个排序链表
二叉搜索树中的第3大个结点（在面试官提示下进行剪枝）O（1）空间复杂度

1假如没有数据了三次挥手行不行
直达链接：计算机网络----三次握手四次挥手

2 服务器怎么就知道自己没数据了
https://blog.csdn.net/weixin_41563161/article/details/104941167

3 tcp和http有什么联系

HTTP是应用层协议，定义的是传输数据的内容的规范

不同主机的应用层之间经常需要可靠的、像管道一样的连接，但是IP层不提供这样的流机制，而是提供不可靠的包交换。

TCP即传输控制协议（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通讯协议。
HTTP协议中的数据是利用TCP协议传输的，所以支持HTTP也就一定支持TCP
应用层向TCP层发送用于网间传输的、用8位字节表示的数据流，然后TCP把数据流分区成适当长度的报文段（通常受计算连接的网络的数据链路层的最大传输单元（MTU）的限制）。之后TCP把结果包传输给IP层，有它来通过网络将包传送给接收端实体的TCP层。

当应用层向TCP层发送用于网间传输的、用8位字节表示的数据流，TCP则把数据流分割成适当长度的报文。之后TCP把数据包传递给IP层，由它来通过网络将包传送给接收端实体的TCP层。

直达链接：程序员必考—http\https的连接过程

直达链接：计算机网络分层\协议详解

直达链接：计算机网络----三次握手四次挥手

4 http请求方法（深入的）head是干什么的

直达链接:一篇让你彻底了解http请求报文和响应报文的结构

5 线程如何结束
https://blog.csdn.net/weixin_41563161/article/details/104942044
1使用标志位
这种方法是我尝试终止线程时最初采用的方法，使用起来很方便，原理也很简单，只要在while循环里持续判断一个Boolean变量的值就可以了，一旦满足离开循环的条件，那么就可以离开线程的方法体，结束线程。
2 使用Interrupt方法（中断）

1.线程处于阻塞状态，如使用了sleep,同步锁的wait,socket中的receiver,accept等方法时，会使线程处于阻塞状态。当调用线程的interrupt()方法时，会抛出InterruptException异常。阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后break跳出循环状态，从而让我们有机会结束这个线程的执行。通常很多人认为只要调用interrupt方法线程就会结束，实际上是错的，一定要先捕获InterruptedException异常之后通过break来跳出循环，才能正常结束run方法。
2.线程未处于阻塞状态，使用isInterrupted()判断线程的中断标志来退出循环。当使用interrupt()方法时，中断标志就会置true，和使用自定义的标志来控制循环是一样的道理。

3为什么要区分进入阻塞状态和和非阻塞状态两种情况了，是因为当阻塞状态时，如果有interrupt()发生，系统除了会抛出InterruptedException异常外，还会调用interrupted()函数，调用时能获取到中断状态是true的状态，调用完之后会复位中断状态为false，所以异常抛出之后通过isInterrupted()是获取不到中断状态是true的状态，从而不能退出循环，

6 如何保证线程安全性
1、synchronized 锁（偏向锁，轻量级锁，重量级锁）
2、volatile 英[ˈvɒlətaɪl]锁，只能保证线程之间的可见性，但不能保证数据的原子性
3、jdk1.5 并发包中提供的 Atomic 原子类 CAS
4、Lock 锁
5. 多实例、或者是多副本（ThreadLocal）：当使用 ThreadLocal 维护变量时，ThreadLocal
为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副
本，而不会影响其它线程所对应的副本

7 实现线程同步的几种方式总结
1 通过Object的wait和notify
2 通过Condition的awiat和signal
3 通过一个阻塞队列
4通过同步辅助类CountDownLatch
5 通过同步辅助类CyclicBarrier

8 深拷贝浅拷贝
https://blog.csdn.net/weixin_41563161/article/details/101628243

9 线程池，核心线程是干嘛的

https://blog.csdn.net/weixin_41563161/article/details/105304160（Java线程池实现原理—美团技术栈）

https://blog.csdn.net/weixin_41563161/article/details/103666165（线程池）

https://blog.csdn.net/weixin_41563161/article/details/105167708（线程池详解）

https://blog.csdn.net/weixin_41563161/article/details/104889470（线程池关闭以及状态）

10 volatile 只用它保持线程安全行不行

https://blog.csdn.net/weixin_41563161/article/details/103869694(lock,sychronized，volatile的区别)

https://blog.csdn.net/weixin_41563161/article/details/102723400(多线程知识点)

11 GC

https://blog.csdn.net/weixin_41563161/article/details/103882414（G1和CMS区别）

https://blog.csdn.net/weixin_41563161/article/details/103865628（分代回收算法）

https://blog.csdn.net/weixin_41563161/article/details/104093660（GC回收机制（垃圾回收器经典算法）（JVM中内存区域的划分）（GC收集器有哪些））

12 Full Gc期间整个虚拟机是什么状态
CMS那一块具体看jvm书籍

点击你们要的免费书来了获取jvm书

13 Java 有哪些锁
在并发编程中，经常遇到多个线程访问同一个共享资源，这时候作为开发者必须考虑如何维护数据一致性，在java中synchronized关键字被常用于维护数据一致性。synchronized机制是给共享资源上锁，只有拿到锁的线程才可以访问共享资源，这样就可以强制使得对共享资源的访问都是顺序的，因为对于共享资源属性访问是必要也是必须的。
对象锁和类锁
根据使用方式的不同一般我们会将锁分为对象锁和类锁，两个锁是有很大差别的，对象锁是作用在实例方法或者一个对象实例上面的，而类锁是作用在静态方法或者Class对象上面的。一个类可以有多个实例对象，因此一个类的对象锁可能会有多个，但是每个类只有一个Class对象，所以类锁只有一个。类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定的是实例方法还是静态方法区别的。

对象锁类锁
同一对象不同加锁的非静态方法互斥
同一对象一个加锁一个不加锁非静态方法不互斥
不同对象不同加锁的非静态方法不互斥

两个对象两个静态加锁方法（与对象无关）互斥
把一个方法写成静态, 一个不静态, 都加锁（静态与非静态方法不共用锁）不互斥

1可重入锁

2可中断锁
lockInterruptibly()的用法时已经体现了Lock的可中断性。
3公平锁
公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。
非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。
在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。

4 读写锁
读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。
正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。
ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。
可以通过readLock()获取读锁，通过writeLock()获取写锁。

读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。
https://www.cnblogs.com/aspirant/p/6930436.html

5 自旋锁
如果持有锁的线程能在很短时间内释放锁资源，那么那些等待竞争锁的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态，它们只需要等一等（自旋），等持有锁的线程释放锁后即可立即获取锁，这样就避免用户线程和内核的切换的消耗。

首先是一种锁，与互斥锁相似，基本作用是用于线程（进程）之间的同步。与普通锁不同的是，一个线程A在获得普通锁后，如果再有线程B试图获取锁，那么这个线程B将会挂起（阻塞）；试想下，如果两个线程资源竞争不是特别激烈，而处理器阻塞一个线程引起的线程上下文的切换的代价高于等待资源的代价的时候（锁的已保持者保持锁时间比较短），那么线程B可以不放弃CPU时间片，而是在“原地”忙等，直到锁的持有者释放了该锁，这就是自旋锁的原理，可见自旋锁是一种非阻塞锁。

二、自旋锁可能引起的问题：
1.过多占据CPU时间：如果锁的当前持有者长时间不释放该锁，那么等待者将长时间的占据cpu时间片，导致CPU资源的浪费，因此可以设定一个时间，当锁持有者超过这个时间不释放锁时，等待者会放弃CPU时间片阻塞；
2.死锁问题：试想一下，有一个线程连续两次试图获得自旋锁（比如在递归程序中），第一次这个线程获得了该锁，当第二次试图加锁的时候，检测到锁已被占用（其实是被自己占用），那么这时，线程会一直等待自己释放该锁，而不能继续执行，这样就引起了死锁。因此递归程序使用自旋锁应该遵循以下原则：递归程序决不能在持有自旋锁时调用它自己，也决不能在递归调用时试图获得相同的自旋锁。

14 Wait 和notify分别是干嘛的

Object.nofity() 的文档明确说一个随机的线程将被唤醒，但具体情况将由实现者决定，因为Object.nofity()是一个native方法。（具体的jvm来实现）
Condition.signal() 的文档则说一个被选定的线程将被唤醒。

可以清晰的看到notify()方法是按先进先出的顺序唤醒的，即是公平的。本实验在Java 1.8 HotSpot 下测试，可以看出Java 1.8 HotSpot把notify()实现为公平的方式。

15 类加载

https://blog.csdn.net/weixin_41563161/article/details/103550512

16 双亲委派模型

https://blog.csdn.net/weixin_41563161/article/details/103885802

17 Socket如何解决丢包

https://blog.csdn.net/weixin_41563161/article/details/105310459(TCP通信丢包原因总结)

https://blog.csdn.net/weixin_41563161/article/details/104173526(TCP粘包现象)

18 其它网络通信的方式

heissen，dubbo，webservice，thrift
dubbo
Dubbo(读音[ˈdʌbəʊ])是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和 [1] Spring框架无缝集成。
webservice
Web Service是一个平*立的，低耦合的，自包含的、基于可编程的web的应用程序，可使用开放的XML（标准通用标记语言下的一个子集）标准来描述、发布、发现、协调和配置这些应用程序，用于开发分布式的交互操作的应用程序。
Thrift
是一种接口描述语言和二进制通讯协议，它被用来定义和创建跨语言的服务。它被当作一个远程过程调用（RPC）框架来使用，是由Facebook为“大规模跨语言服务开发”而开发的。

19 CAS Synchronized Voliate
synchronized
synchronized英[ˈsɪŋkrənaɪzd] 同步代码块的语义底层是基于对象内部的监视器锁（monitor），分别是使用 monitorenter 和 monitorexit 指令完成。其实 wait/notify 也依赖于 monitor 对象，所以其一般要在 synchronized 同步的方法或代码块内使用。monitorenter 指令在编译为字节码后插入到同步代码块的开始位置，monitorexit 指令在编译为字节码后插入到方法结束处和异常处。JVM 要保证每个 monitorenter 必须有对应的 moniorexit。
cas

volatile

https://blog.csdn.net/weixin_41563161/article/details/103869694

2.2腾讯1面（部门：腾讯云盘、时间：120分钟）

1 打印字节数
https://blog.csdn.net/weixin_41563161/article/details/104993568

2 arraycopy

public class Test6 {
    public static void main(String[] args) {
        int[] formArray={101,102,103,104,105,106};
        int[] toArray={201,202,203,204,205,206,207};
        System.arraycopy(formArray, 2, toArray, 3, 2);
        for(int i=0;i<toArray.length;i++){
            System.out.println(i+":"+toArray[i]);
        }
    }

    public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) {
     // TODO 请完成实现部分
    }

}

3 旋转数组
点击直达：剑指offer–旋转数组的最小数字

4 多线程循环打印abc

点击直达：线程间通信—数字交替打印(循环打印abc)

2.3腾讯1面（部门：PCG、时间：120分钟）

算法题

：运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作：获取数据 get 和写入数据 put 。
获取数据 get(key)：如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) ：如果密钥不存在，则写入（设置或插入）其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
示例:
LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1); // 返回 1
cache.put(3, 3); // 该操作会使得密钥 2 作废
cache.get(2); // 返回 -1 (未找到)
cache.put(4, 4); // 该操作会使得密钥 1 作废
cache.get(1); // 返回 -1 (未找到)
cache.get(3); // 返回 3
cache.get(4); // 返回 4
评价：对 LRU 机制比较熟悉，算法阐述比较清晰，写代码过程没有像第一题一样的混乱。

解决方案：

解决方案：
//定义链表节点
class Node{
  int key;
  int value;
  Node pre;
  Node next;
  public Node(int key,int value){
      this.key = key;
      this.value = value;
  }
}
public class LRUCache{
    Map<Integer,Node> cacheMap = new HashMap<>();
    //定义哈希表
    Node head = null;
    //定义头节点
    Node tail = null;
    //定义尾节点
    int nodeLength =0;
    //容量
    //put操作
    public int get(int key){
    if(cacheMap.containsKey(key)){
    //如果存在的话
    Node node =cacheMap.get(key);
    removeNode(node);
    //进行移除
    setHead(node);
    //把节点放到首部
    return node.value;
    //返回节点
    }
    return -1；
    //不存在返回-1；
}
//移除链表中的节点
public void removeNode(Node node){
    if(node.pre != null){
    //如果前节点不为空
    node.pre.next = node.next;
    }else{
    //前节点为空
    head = node.next;
    }
    if(node.next != null){
    //后节点不为空
    node.next.pre = node.pre;
    }else{
    后节点为空
    tail = node.pre;
    }
}
//把节点放到链表的头部
public void setHead(Node node){
    node.next = head;
    node.pre = null;
    if(head != null){
        //如果头结点不为空
        head.pre = node;
    }else{
        head = node;
        //头结点为空
    }
    if(tail == null){
        //如果尾部节点为空
        tail = head;
     }
 }
//put操作
public void put(int key,int value){
    if(cacheMap.containsKey(key)){
        //如果包含key的话
        Node oldNode = cacheMap.get(key);
        //取出旧的值
        oldNode.value = value;
        //替换旧的值
        remove(oldNode);
        //移除链表中的旧的值
        setHead(oldNode);
        //把旧的值放到首部
    }else{
      //不包含的情况
      Node newNode = new Node(key,value);
      //考虑容量是否足够
        if(cacheMap.size() >= nodeLength){
            //容量不够的话
            cacheMap.remove(tail.key);
            //哈希表去掉尾部值
            remove(tail);
            //删除链表尾部
            setHead(newNode);
            //把新的链表放到头部位置
        }else{
            setHead(newNode);
            容量够的话
            }
            cacheMap.put(key,newNode);
            //放入到hashmap中
        }
    }  
}

2.5腾讯1面（部门：光子、时间：120分钟）

1封装继承多态

https://blog.csdn.net/weixin_41563161/article/details/108953004（
多态）

https://blog.csdn.net/weixin_41563161/article/details/104092923（
Java的多态与实现）

2 GC

https://blog.csdn.net/weixin_41563161/article/details/103882414（G1和CMS区别）

https://blog.csdn.net/weixin_41563161/article/details/103865628（分代回收算法）

https://blog.csdn.net/weixin_41563161/article/details/104093660（GC回收机制（垃圾回收器经典算法）（JVM中内存区域的划分）（GC收集器有哪些））

3两个链表的公共入口
https://blog.csdn.net/weixin_41563161/article/details/102910326

时间复杂度 m+n

4三次握手四次挥手中

计算机网络----三次握手四次挥手

5数据库索引

https://blog.csdn.net/weixin_41563161/article/details/102610132(B树 B+树红黑树详解)

https://blog.csdn.net/weixin_41563161/article/details/104163948(b树和b+树的区别)

https://blog.csdn.net/weixin_41563161/article/details/105483950(B+树分裂)

https://blog.csdn.net/weixin_41563161/article/details/105165346（索引）

https://blog.csdn.net/weixin_41563161/article/details/103553313（数据库索引怎么实现的）

https://blog.csdn.net/weixin_41563161/article/details/102859171（普通索引和唯一索引，应该怎么选择？）

https://blog.csdn.net/weixin_41563161/article/details/102457643（深入浅出索引）

6数据库引擎

https://blog.csdn.net/weixin_41563161/article/details/105170148?

7连接池
连接池的应用场景

8 char() varchar()区别
varchar(50) 是什么意思

9 垃圾回收

https://blog.csdn.net/weixin_41563161/article/details/103882414（G1和CMS区别）

https://blog.csdn.net/weixin_41563161/article/details/103865628（分代回收算法）

https://blog.csdn.net/weixin_41563161/article/details/104093660（GC回收机制（垃圾回收器经典算法）（JVM中内存区域的划分）（GC收集器有哪些））

10 TCP 与UDP

一篇让你掌握TCP与UDP首部格式

2.6腾讯2面（部门：光子、时间：40分钟）

1 关系型数据库非关系型数据库
https://blog.csdn.net/weixin_41563161/article/details/105619871

3查询语句排序语句
“select * from say order by id desc limit 100,15”

3TreeMap优势

1 红黑树是牺牲了严格的高度平衡的优越条件为代价，它只要求部分地达到平衡要求，降低了对旋转的要求，从而提高了性能。

2红黑树能够以O(log2n)的时间复杂度进行搜索、插入、删除操作。此外，由于它的设计，任何不平衡都会在三次旋转之内解决。当然，还有一些更好的，但实现起来更复杂的数据结构能够做到一步旋转之内达到平衡，但红黑树能够给我们一个比较“便宜”的解决方案。

3结合TreeMap
TreeMap 实现了 SortMap 接口，其能够根据键排序，默认是按键的升序排序，也可以指定排序的比较器，当用 Iterator 遍历 TreeMap 时得到的记录是排过序的，TreeMap 取出来的是排序后的键值
4红黑树占用的内存更小（仅需要为其存在的节点分配内存），而Hash事先应该分配足够的内存存储散列表,即使有些槽可能弃用

https://blog.csdn.net/weixin_41563161/article/details/104986919(TreeMap使用场景优势)

https://blog.csdn.net/weixin_41563161/article/details/102610132(B树 B+树红黑树详解)

https://blog.csdn.net/weixin_41563161/article/details/104163948(b树和b+树的区别)

https://blog.csdn.net/weixin_41563161/article/details/104163994(TreeMap了解吗红黑树)

https://blog.csdn.net/weixin_41563161/article/details/105462349(红黑树叶子节点都为黑色)

https://blog.csdn.net/weixin_41563161/article/details/104452601(java面试 –红黑树（插入删除过程详解）)

4堆和栈的区别

栈：主要用于存储局部变量和对象的引用变量，每个线程都会有一个独立的栈空间，所以线程之间是不共享数据的。

堆内存主要作用是存放运行时创建(new)的对象。
（主要用于存放对象，存取速度慢，可以运行时动态分配内存，生存期不需要提前确定）

堆：主要用于存储实例化的对象，数组。由JVM动态分配内存空间。一个JVM只有一个堆内存，线程是可以共享数据的。

5内存模型

https://blog.csdn.net/weixin_41563161/article/details/105316381（Java内存模型）

https://blog.csdn.net/weixin_41563161/article/details/102670179（Java内存分布、常量池、运行时数据区域）

6Jvm是干什么的

JVM 是 Java Virtual Machine（Java 虚拟机）的缩写，它是整个 java实现跨平台的最核心的部分，所有的 java 程序会首先被编译为.class 的类文件，这种类文件可以在虚拟机上执行，也就是说 class 并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解释给本地系统执行。JVM 是 Java 平台的基础，和实际的机器一样，它也有自己的指令集，并且在运行时操作不同的内存区域。JVM 通过抽象操作系统和 CPU 结构，提供了一种与平台无关的代码执行方法，即与特殊的实现方法、主机硬件、主机操作系统无关。JVM 的主要工作是解释自己的指令集（即字节码）到 CPU 的指令集或对应的系统调用，保护用户免被恶意程序骚扰。JVM 对上层的 Java 源文件是不关心的

结构和操作系统有关，是运行 Java 程序必不可少的（除非用其他一些编译环境编译成.exe 可执行文件……），JRE 的地位就象一台 PC 机一样，我们写好的 Win32 应用程序需要操作系统帮我们运行，同样的，我们编写的 Java程序也必须要 JRE 才能运行。

JVM是java字节码执行的引擎，还能优化java字节码，使之转化成效率更高的机器指令。
JVM中类的装载是由类加载器和它的子类来实现的，类加载是java运行时一个重要的系统组件，负责在运行时查找和装入类文件的类。
不同的平台对应着不同的JVM，在执行字节码(class文件)时，JVM负责将每一条要执行的字节码送给解释器，解释器再将其翻译成特定平台换将的机器指令并执行，这样就实现了跨平台运行。

内存区域
1，程序计数器
程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，可以理解为是当前线程的行号指示器。它是线程私有（一个线程就有一个程序计数器）的。
2，虚拟机栈
一个线程的每个方法在执行的同时，都会创建一个栈帧（Statck Frame），栈帧中存储的有局部变量表、操作站、动态链接、方法出口等，当方法被调用时，栈帧在JVM栈中入栈，当方法执行完成时，栈帧出栈。
每个线程对应着一个虚拟机栈，因此虚拟机栈也是线程私有的。

栈：主要用于存储局部变量和对象的引用变量，每个线程都会有一个独立的栈空间，所以线程之间是不共享数据的。

3，本地方法栈
本地方法栈在作用，运行机制，异常类型等方面都与虚拟机栈相同，唯一的区别是：虚拟机栈是执行Java方法的，而本地方法栈是用来执行native方法的，
4，堆区
堆内存主要作用是存放运行时创建(new)的对象。
（主要用于存放对象，存取速度慢，可以运行时动态分配内存，生存期不需要提前确定）

堆：主要用于存储实例化的对象，数组。由JVM动态分配内存空间。一个JVM只有一个堆内存，线程是可以共享数据的。
5，方法区
方法区是各个线程共享的区域，用于存储已经被虚拟机加载的类信息（即加载类时需要加载的信息，包括版本、field、方法、接口等信息）、final常量、静态变量、编译器即时编译的代码等。

7struct 和 c++的类怎么区分
C/C++结构体的区别
C中的结构体和C++中结构体的不同之处：在C中的结构体只能自定义数据类型，结构体中不允许有函数，而C++中的结构体可以加入成员函数。

结构体定义中默认情况下的成员是public，而类定义中的默认情况下的成员是private的。类中的非static成员函数有this指针，（而struct中没有是错误的，一直被误导啊，经过测试struct的成员函数一样具有this指针），类的关键字class能作为template模板的关键字即template class A{}; 而struct不可以。

C的结构体只是把数据变量给包裹起来了，并不涉及算法。
而C++是把数据变量及对这些数据变量的相关算法给封装起来，并且给对这些数据和类不同的访问权限。

C语言中是没有类的概念的，但是C语言可以通过结构体内创建函数指针实现面向对象思想。

8 项目被打断
因为这里注重的是基础

9 TCP UDP
一篇让你掌握TCP与UDP首部格式

10工作线程

11 Linux 查看进程创建文件

https://blog.csdn.net/weixin_41563161/article/details/102618800?

https://blog.csdn.net/weixin_41563161/article/details/105306067

12游标

游标实际上是一种能从包括多条数据记录的结果集中每次提取一条记录的机制。

游标允许应用程序对查询语句select 返回的行结果集中每一行进行相同或不同的操作，而不是一次对整个结果集进行同一种操作；

13存储过程
存储过程（Stored Procedure），计算机用语，是一组为了完成特定功能的SQL语句集，是利用SQL Server所提供的Transact-SQL语言所编写的程序。经编译后存储在数据库中。存储过程是数据库中的一个重要对象，用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。存储过程是由流控制和SQL语句书写的过程，这个过程经编译和优化后存储在数据库服务器中，存储过程可由应用程序通过一个调用来执行，而且允许用户声明变量。同时，存储过程可以接收和输出参数、返回执行存储过程的状态值，也可以嵌套调用。

14二叉搜索树的时间复杂度冒泡排序时间复杂度

直达链接：【offerMe–数据结构】----排序算法

15 进程间通信

1 管道

2 消息队列

这种通信方式有缺点吗？答是有的，如果 a 进程发送的数据占的内存比较大，并且两个进程之间的通信特别频繁的话，消息队列模型就不大适合了。因为 a 发送的数据很大的话，意味发送消息（拷贝）这个过程需要花很多时间来读内存。
3共享内存

16 流量控制，拥塞控制

https://blog.csdn.net/weixin_41563161/article/details/106088167（拥塞控制流量控制区别）

https://blog.csdn.net/weixin_41563161/article/details/104218014（TCP流量控制机制、拥塞控制）

2.7腾讯3面（部门：光子、时间：40分钟）

1如何把大量的文件快速读完

值得大家去探索

2项目

梦想成真-----项目自我介绍

3.腾讯面试感受

一定不要放弃，我腾讯面了7次才上岸。
提前批找自己的师兄师姐帮忙内推，腾讯会有很多机会。
一定要有一个特别突出的地方让面试官对你有好印象，比如数据库或者操作系统，你能讲出自己的理解以及底层东西出来。
即使是拿到offer了，继续面试，保持面试的状态。
腾讯的面试官很好，所以放轻松尽情的表达自己就 OK了。

本公众号分享自己从程序员小白到经历春招秋招斩获10几个offer的面试笔试经验，其中包括【Java】、【操作系统】、【计算机网络】、【设计模式】、【数据结构与算法】、【大厂面经】、【数据库】期待你加入！！！

1.计算机网络----三次握手四次挥手
2.梦想成真-----项目自我介绍
3.你们要的设计模式来了
4.震惊！来看《这份程序员面试手册》！！！
5.一字一句教你面试“个人简介”
6.接近30场面试分享
7.你们要的免费书来了

码农公寓

​1.序

​2.腾讯面试过程

2.1腾讯1面 （部门：WXG、时间：120分钟）

2.2腾讯1面 （部门：腾讯云盘、时间：120分钟）

2.3腾讯1面 （部门：PCG、时间：120分钟）

2.5腾讯1面 （部门：光子、时间：120分钟）

2.6腾讯2面 （部门：光子、时间：40分钟）

2.7腾讯3面 （部门：光子、时间：40分钟）

相关文章

1.序

2.腾讯面试过程

2.1腾讯1面（部门：WXG、时间：120分钟）

2.2腾讯1面（部门：腾讯云盘、时间：120分钟）

2.3腾讯1面（部门：PCG、时间：120分钟）

2.5腾讯1面（部门：光子、时间：120分钟）

2.6腾讯2面（部门：光子、时间：40分钟）

2.7腾讯3面（部门：光子、时间：40分钟）