大数据开发总结

个人总结

kafka

1、kafka的消费者组是如何消费的？

一个分区只能被消费者组中的一个消费者消费
一个消费者组中的一个消费者可以消费多个分区
一个消费者组中的不同消费者消费的分区一定不会重复
一个topic可以有多个consumer group，但每个partition只会把消息发给该consumer group中的一个consummer

2、kafka为什么有消费者组？

（1）消费效率高
（2）消费模式灵活(广播模式，单播模式)
（3）便于故障容灾
https://blog.csdn.net/john1337/article/details/103060820

java

1、进程间通信的方法，共享内存这种方式要注意什么问题？

https://www.cnblogs.com/joker-wz/p/11000489.html
linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程和全局变量在另一个进程中看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1吧数据从用户空间考到内核缓冲区，进程2在从内核缓冲区把数据读走，内核提供的这种机制叫做进程间通信。
在进程间完成数据传递需要借助操作系统的提供的特殊方法，如管道、命名管道、信号、消息队列、共享内存、信号量、套接字等。

使用共享内存效率高，但是问题如下：
（1）内存大小
（2）看这个地址吧 https://blog.csdn.net/weixin_30872671/article/details/96263270

2、线程与进程的区别

进程。
进程是程序的一次执行过程，是个动态概念。是程序在执行过程中分配和管理资源的基本单位，每个进程都有一个自己的地址空间。
线程。
线程是CPU调度和分派的基本单位，它可与同属一个进程的其他线程共享进程的拥有的资源。
区别

根本区别：进程是操作系统分配资源的基本单位，而线程是任务调度和执行的基本单位。
开销方面：每个进程都有独立的代码和数据空间（程序上下文），程序之间切换会有较大的开销；线程可看成是轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器，线程之间切换开销小。
内存分配方面：系统在运行时会为每个进程分配不同的内存空间；而线程，除了CPU外，系统不会为线程分配内存。
一个进程可以包含>=1个线程。

3、TCP三次握手

第一次：客户主动连接服务器，向服务器发送SYN，假设系列号是J，服务器被动打开
第二次：服务器收到SYN后，会发送一个SYN和一个ACK给用户，ACK的序列号是J+1， SYN的序列号是K
第三次：客户收到信的SYN和ACK后，会向服务器回应ACK K+1，表示收到了，然后两边就可以开始发送数据了

4、get和post的区别

get和post是HTTP请求的两种基本方法，
区别：

• 最直观的区别就是get把参数包含在URL中，POST通过request body传递参数
• get传输的数据量小，因为受到URL长度限制；而post可以传输大量的数据
• get是从服务器上获得数据，而post则是向服务器传递数据的
• get不安全，因为一些操作可能被第三方看到，而post的所有操作对用户是不可见的
• 值的字符集不同

5、http状态码

• 1开头：信息状态码
• 2开头：成功状态码
• 3开头：重定向状态码
• 4开头：客户端错误状态码
• 5开头：服务端错误状态码

6、线程的同步方式？区别

1.有synchronized关键字修饰的方法
由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态
2.有synchronized修饰的代码块
被该关键字修饰的语句块会自动被加上内置锁，从而实现同步
3.使用特殊域变量volatile实现线程同步
原理是每次线程要访问volatile修饰的变量时都是从内存中读取，而不是从缓存中读取，因此每个线程访问到的变量都是一样的，这样就保证了同步。
volatile不能保证原子操作，因此volatile不能代替synchronized。此外volatile会组织编译器对代码优化，降低了程序的执行效率
4.使用重入锁实现同步
java.util.concurrent包来支持同步
此时注意及时释放锁
5.使用局部变量实现线程同步
ThreadLocal

6、死锁

1、什么是死锁

由于两个过着两个以上的线程相互持有对方需要的资源，导致这些线程处于等待状态，无法执行

2、产生死锁的四个必要条件

1. 互斥性：线程对资源的战友是排他性的，一个资源只能被一个线程占有，直到释放
2. 请求和保持条件：一个线程对请求被占有资源发生阻塞时，对已经获得的资源不释放
3. 不剥夺：一个线程在释放资源之前，其他的线程无法剥夺占用
4. 循环等待：发生死锁时，线程进入死循环吗，永久阻塞

3、产生死锁的原因

1. 竞争不可抢占性资源：P1已经打开了F1，想去打开F2，P2已经打开了F2，想去打开F1，但是F1和F都是不可抢占的，这是发生死锁
2. 竞争可消耗资源引起死锁：进行间通信，如果顺序不当，会产生死锁。
3. 进程推进顺序不当：进程在运行过程中，请求和释放资源的顺序不当，也同样会导致进程死锁

4、避免死锁的方法

1. 破坏“请求和保持”条件
   想办法让进程不那么贪心，自己已经有了资源就不要去竞争那些不可抢占的资源
   2.破坏不可抢占资源
   允许进程进行抢占，如果去抢资源，就是放自己的资源；或只要优先级大，可以抢到
   3.破坏“循环等待”条件
   将系统中的所有资源统一编号，进程可在任何时刻提出资源申请，但所有申请必须按照资源的编号顺序提出

5、死锁的检测

1、每个进程、每个资源指定唯一编号
2、设定一张资源分配表，记录各进程与占用资源之间的关系
3、设置一张进程等待表，记录各进程与要申请资源之间的关系

6、死锁的解除

1、抢占资源，从一个或多个进程中抢占足够数量的资源，分配给死锁进程，以解除死锁状态
2、终止（撤销）进程，终止（或撤销）系统中的一个或者多个死锁进程，直到打破循环换了，是系统从死锁状态解脱出来

7、JVM的四种GC算法（垃圾收集的方法）

1. 引用计数法：每个对象在创建的时候，就给这个对象绑定一个计数器。每当有一个引用指向该对象时，计数器加1；每当有一个指向他的引用被删除时，计数器减1.当计数器为0时，进行垃圾回收
2. 标记-清除：标记那些要被回收的对象，然后统一回收
3. 标记-整理：该算法只要是解决标记-清除，产生大量内存碎片的问题；当对象存活率较高时，也解决了复制算法的效率问题。他的不同之处就是在清除对象的时候将可回收对象移动到一端，然后清除掉端边界以外的对象，这样就不会产生内存碎片。
4. 复制算法：该算法将内存平均分成两部分，然后每次只使用其中的一部分，当这部分存满的时候，将内存中所有存活的对象复制到另一个内存中，然后将之前的内存清空，只使用这部分内存，循环下去
5. 分代收集器：根据对象的生存周期，将堆分为新生代和老年代。在新生代中，由于对象生存期短，每次回收都会有大量对象死去，那么这时采用复制算法。老年代里面的对象存活率较高，没有额外的空间进行分配担保，所以可以使用标记-整理或者标记-清除

数据库

1、数据库的ACID属性

1. 原子性(Atomactic)：要么全部做完，要么全部不做
2. 一致性(Consistency)：如A向B转账，不可能A扣了钱，B却没收到
3. 隔离性(Isolation)：同一时间，只允许一个事务请求同一数据，不同事物之间彼此没有任何干扰
4. 持久性(Durability)：事务完成后，事务对数据库的所有更新将被保存到数据库，不能回滚

2、事务的隔离级别

事务隔离级别	脏读	不可重复读	幻读
读未提交（read-uncommitted）	是	是	是
不可重复读（read-committed）	否	是	是
可重复读（repeatable-read）	否	否	是
串行化（serializable）	否	否	否

(1) 未提交读
A事务已执行，但未提交；B事务查询到A事务的更新后数据；A事务回滚；—出现脏数据
(2) 已提交读
A事务执行更新；B事务查询；A事务又执行更新；B事务再次查询时，前后两次数据不一致 ---- 不可重复读
(3) 可重复读（默认）
A事务无论执行多少次，只要不提交，B事务查询值都不变；B事务仅查询A事务开始时那一瞬间的数据快照
(4) 串行化
不允许读写并发操作，写执行时，读必须等待

3、B-树和B+树

1、B-树将关键字、索引和记录都存放在一起；B+树的非叶子节点中只有关键字和指向下一个节点的索引，记录放在叶子节点中
2、在B-树中，越靠近根节点的记录查找时间越快，只要找到关键字即可确定记录的存在；在B+树中每个记录的查找时间基本是一样的，都需要从根节点走到叶子节点，而且在叶子节点中还要再比较关键字

4、为什么索引能够提高查询速度

5、最左前缀原则

最左前缀原则是发生在复合索引上的，只有复合索引才会有所谓的左和右之分。

项目

1、项目中用到的shell脚本

（1）Flume启动停止脚本

#!/bin/bash
case $1 in 
"start") {
	for i in hd1 hd2 hd3
	do 
		ssh $i "nohup /flume-ng agent --conf-file file-flume-kafk.conf --name a1 -Dflume.root.logger=INFO,LOGFILE > /dev/null 2> &1 &"
	done
};;
"stop" ){
	for i in hd1 hd2 hd3 
	do
	 	ssh $i "ps -ef | grep file-flume-kafka |grep -v grep | awk '{print \$2}' | xargs kill"
	done
};;
esac

（2）kafka启动停止脚本

#!/bin/bash
case $1 in
"start"){
	for i in hd1 hd2 hd3 
	do 
		ssh $i "export JMX_PORT=9988 && kafka-server-start.sh -daemon server.properties"
	done
 };;
"stop"){
	for i in hd1 hd2 hd3
	do 
		ssh $i "kafka-server-stop.sh stop"
	done
};;
esac

（3）采集通道启动/停止脚本

#! /bin/bash

case $1 in
"start"){
	echo " -------- 启动 集群 -------"

	echo " -------- 启动 hadoop集群 -------"
	/opt/module/hadoop-2.7.2/sbin/start-dfs.sh 
	ssh hadoop103 "/opt/module/hadoop-2.7.2/sbin/start-yarn.sh"

	#启动 Zookeeper集群
	zk.sh start

sleep 4s;

	#启动 Flume采集集群
	f1.sh start

	#启动 Kafka采集集群
	kf.sh start

sleep 6s;

	#启动 Flume消费集群
	f2.sh start

	};;
"stop"){
    echo " -------- 停止 集群 -------"

    #停止 Flume消费集群
	f2.sh stop

	#停止 Kafka采集集群
	kf.sh stop

    sleep 6s;

	#停止 Flume采集集群
	f1.sh stop

	#停止 Zookeeper集群
	zk.sh stop

	echo " -------- 停止 hadoop集群 -------"
	ssh hadoop103 "/opt/module/hadoop-2.7.2/sbin/stop-yarn.sh"
	/opt/module/hadoop-2.7.2/sbin/stop-dfs.sh 
};;
esac

spark

1、持久化和checkpoint的区别

• 持久化只是将数据保存在BlockManager中，而RDD的Lineage是不变的。但是checkpoint执行之后，RDD已经没有之前所谓的依赖RDD了，而只有一个强行为其设置的checkpointRDD，RDD的Lineage改变了
• 持久化的数据丢失的可能性更大，因为磁盘和内存可能会存在数据丢失的情况。但是checkpoint的数据通常是存储在HDFS等容错、高可用的文件系统和中，数据丢失的可能性小
• 没有持久化，直接使用checkpoint的话，会计算两次。所以先checkpoint，在cache

滴滴大数据开发（实习）

一面（电话）

1、说一下RDD

2、hive的优化

列式存储（ORC、parque）
忘说LZO压缩格式存储

3、HIVE为什么列式存储算是优化？

https://www.cnblogs.com/bigdatafly/articles/5037745.html
比较行式存储和列式存储
（1）行式存储
优点：基于hadoop系统运行存储结构的优点在于快速数据加载和动态负载的高适应能力，这是因为行存储保证了相同的记录的所有域都在同一个集群节点，即同一个HDFS
缺点：不支持快速查询处理，因为他不能跳过不必要的列读取，压缩比大
（2）列式存储
优点：查询时列存储可以避免读不必要的列，容易得到较大的压缩比
缺点：列存储不能保证同一记录的所有域都存储在同一节点，会导致大量的IO传输

所以，使用列存储的话，最好配合使用压缩，获得最大压缩比

4、spark的内存管理

5、spark的shuffle过程

持续更新ing……