测试/测试开发复习2

HTTPS的优缺点

进程和线程的区别

链表和线性表

set与hashset的区别

map与hashmap的区别

HashMap和Hashtable的区别

final 、finally、finalize的区别

JAVA的数据类型

JAVA中的泛型

归并排序原理

常见数据结构的时间复杂度

数据库事务的四个特性

垃圾回收GC

进程的三种状态及其相互间的转换

TCP的3次握手可以2次或者4次吗？

JAVA的拷贝

JAVA的四种引用

堆和栈的区别

UDP能否也像TCP那样安全，怎么做

模拟实现的过程如下

全局变量和局部变量变量名能否一样？

Java实现一个算法，找出一个单链表中倒数第K个结点

ArrayList和LinkedList的大致区别：

常用的加密算法

硬链接和软连接

外挂技术和反外挂技术

白盒测试

HTTPS的优缺点

优点

使用 HTTPS 协议可认证用户和服务器，确保数据发送到正确的客户机和服务器。
HTTPS 协议是由 SSL+HTTP 协议构建的可进行加密传输、身份认证的网络协议，要比 HTTP 协议安全，可防止数据在传输过程中不被窃取、改变，确保数据的完整性。
HTTPS 是现行架构下最安全的解决方案，虽然不是绝对安全，但它大幅增加了中间人攻击的成本。

缺点

相同网络环境下，HTTPS 协议会使页面的加载时间延长近 50%，增加 10%到 20%的耗电。此外，HTTPS 协议还会影响缓存，增加数据开销和功耗。
HTTPS 协议的安全是有范围的，在黑客攻击、拒绝服务攻击和服务器劫持等方面几乎起不到什么作用。
最关键的是，SSL 证书的信用链体系并不安全。特别是在某些国家可以控制 CA 根证书的情况下，中间人攻击一样可行。
成本增加。部署 HTTPS 后，因为 HTTPS 协议的工作要增加额外的计算资源消耗，例如 SSL 协议加密算法和 SSL 交互次数将占用一定的计算资源和服务器成本。在大规模用户访问应用的场景下，服务器需要频繁地做加密和解密操作，几乎每一个字节都需要做加解密，这就产生了服务器成本。随着云计算技术的发展，数据中心部署的服务器使用成本在规模增加后逐步下降，相对于用户访问的安全提升，其投入成本已经下降到可接受程度。

进程和线程的区别

1、根本区别：进程是资源分配最小单位，线程是程序执行的最小单位。计算机在执行程序时，会为程序创建相应的进程，进行资源分配时，是以进程为单位进行相应的分配。每个进程都有相应的线程，在执行程序时，实际上是执行相应的一系列线程。

2、地址空间：进程有自己独立的地址空间，每启动一个进程，系统都会为其分配地址空间，建立数据表来维护代码段、堆栈段和数据段；线程没有独立的地址空间，同一进程的线程共享本进程的地址空间。

3、资源拥有：进程之间的资源是独立的；同一进程内的线程共享本进程的资源。

4、执行过程：每个独立的进程程有一个程序运行的入口、顺序执行序列和程序入口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

5、线程是处理机调度的基本单位，但是进程不是。由于程序执行的过程其实是执行具体的线程，那么处理机处理的也是程序相应的线程，所以处理机调度的基本单位是线程。

6、系统开销：进程执行开销大，线程执行开销小。

链表和线性表

set与hashset的区别

hashset是set的实现类，set是接口，set下面最主要的实现类就是hashset（也就是用的最多的），除此之外的实现类还有linkedhashset,treeset.......

Set存储的元素是无序的，是不可重复的！

hashset特点:1.无序性：无序性！= 随机性。真正的无序性，指的是元素在底层存储的位置是无序的。（根据hash值来存）

2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去。 //说明：要求添加进Set中的元素所在的类，一定要重写equals（）和hashcode（）方法。进而保证set中元素的不可重复性! //set中的元素时如何存储的呢？使用了哈希算法。 //当向set中添加元素时，首先调用此对象所在类的hashCode（）方法，计算此对象的hash值，此哈希值决定了此对象在set中的存储位置，若此位置之前没有对象存储，则此对象直接存到这个位置。（就好比一个教室，按号入座一样），若已有对象存储，在通过equals（）方法比较这两个对象的是否相同，如果相同后一个对象不能再添加进来。 //万一返回false呢？都存储。（不建议如此） //>要求：hashcode（）方法要与equals（）方法一致。

map与hashmap的区别

Map集合的特点：
1、Map集合一次存储两个对象，一个键对象，一个值对象
2、键对象在集合中是唯一的，可以通过键来查找值
HashMap特点：
1、使用哈希算法对键去重复，效率高，但无序
2、HashMap是Map接口的主要实现类

HashMap和Hashtable的区别

HashMap和Hashtable都实现了Map接口，但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有：线程安全性，同步(synchronization)，以及速度。

1. HashMap几乎可以等价于Hashtable，除了HashMap是非synchronized的，并可以接受null(HashMap可以接受为null的键值(key)和值(value)，而Hashtable则不行)。

2. HashMap是非synchronized，而Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的扩展性更好。

3. 另一个区别是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为，要看JVM。这条同样也是Enumeration和Iterator的区别。

4. 由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。

5. HashMap不能保证随着时间的推移Map中的元素次序是不变的。

final 、finally、finalize的区别

一、final ：

1、修饰符（关键字）如果一个类被声明为final,意味着它不能再派生新的子类，不能作为父类被继承。因此一个类不能及被声明为abstract，又被声明为final的。

2、将变量或方法声明为final,可以保证他们使用中不被改变。被声明为final的变量必须在声明时给定初值，而以后的引用中只能读取，不可修改，被声明为final的方法也同样只能使用，不能重载。

二、finally:

在异常处理时提供finally块来执行清楚操作。如果抛出一个异常，那么相匹配的catch语句就会执行，执行完catch语句后，如果有finally块，程序会继续执行finally模块。（不管catch有没有执行，最后都会执行finally模块）

三、finalize：

finalize()是Object中的方法。java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除之前，做必要的清理工作。这个方法是在垃圾收集器在确定了被清理对象没有被引用的情况下调用的。即当一个对象被虚拟机宣告死亡时会先调用它finalize()方法，让此对象处理它生前的最后事情（这个对象可以趁这个时机挣脱死亡的命运）。

finalize是在Object类中定义的，因此，所有的类都继承了它。子类可以覆盖finalize()方法，来整理系统资源或者执行其他清理工作。

JAVA的数据类型

数据类型	默认值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	'u0000'
String (or any object)	null
boolean	false

JAVA中的泛型

Java泛型是J2 SE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法

好处

1，类型安全。泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。
2，消除强制类型转换。消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
3，潜在的性能收益。泛型为较大的优化带来可能，为未来版本的 JVM 的优化带来可能。由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。

Java语言引入泛型的好处是安全简单。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

泛型在使用中还有一些规则和限制：

1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends语句，例如。习惯上成为“有界类型”。
5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName(Java.lang.String);

归并排序原理

该算法是稳定算法，和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

常见数据结构的时间复杂度

| 数据结构                               | 查找   | 插入   | 删除   |
| :------------------------------------- | :----- | :----- | :----- |
| 数组ArrayList                          | o(n)   | o(1)   | o(n)   |
| 有序数组                               | o(lgn) | o(n)   | o(n)   |
| 链表LinkedList                         | o(n)   | o(1)   | o(n)   |
| 红黑二叉树TreeMap                      | o(lgn) | o(lgn) | o(lgn) |
| 哈希表HashMap (hash碰撞情况都是o(lgn)) | o(1)   | o(1)   | o(1)   |

数据库事务的四个特性

1、原子性（Atomicity）

原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。

2、一致性（Consistency）

一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。

拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。

3、隔离性（Isolation）

隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。

即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。　

4、持久性（Durability）

持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

垃圾回收GC

JVM 内存区域
如何识别垃圾
- 引用计数法
- 可达性算法
垃圾回收主要方法
- 标记清除法
- 复制法
- 标记整理法
- 分代收集算法

进程的三种状态及其相互间的转换

1.进程的三种基本状态

进程在运行中不断地改变其运行状态。通常，一个运行进程必须具有以下三种基本状态。

就绪(Ready)状态

当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。

执行（Running）状态
当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。

阻塞(Blocked)状态
正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种，例如，等待I/O完成、申请缓冲区不能满足、等待信件(信号)等。

2.进程三种状态间的转换

一个进程在运行期间，不断地从一种状态转换到另一种状态，它可以多次处于就绪状态和执行状态，也可以多次处于阻塞状态。图3_4描述了进程的三种基本状态及其转换。

　(1) 就绪→执行
处于就绪状态的进程，当进程调度程序为之分配了处理机后，该进程便由就绪状态转变成执行状态。

　(2) 执行→就绪
处于执行状态的进程在其执行过程中，因分配给它的一个时间片已用完而不得不让出处理机，于是进程从执行状态转变成就绪状态。

　(3) 执行→阻塞
正在执行的进程因等待某种事件发生而无法继续执行时，便从执行状态变成阻塞状态。

　(4) 阻塞→就绪
处于阻塞状态的进程，若其等待的事件已经发生，于是进程由阻塞状态转变为就绪状态。

TCP的3次握手可以2次或者4次吗？

TCP作为一种可靠传输控制协议，其核心思想：既要保证数据可靠传输，又要提高传输的效率，而用三次恰恰可以满足以上两方面的需求！

不能改成两次，第三次是为了防止已经失效的连接请求报文段突然又传到了服务器端，因而发生错误。客户端有可能因为网络阻塞等原因会发送多个请求报文,这时服务器就会建立连接,浪费掉许多服务器的资源

没有必要四次，是为了提高传输效率

详细答案1（假设不要第三次握手）

第一步：

客户端发送一个起始序列号seq = x的报文段给服务器。

第二步：

服务器端返回向客户端发送确认号 ack = x+1，表示对客户端的起始序列号x 表示确认，

并告诉客户端，他的起始序列号是 seq = y.

所以，为什么不能两次握手？

1、这种情况下，只有服务器对客户端的起始序列号做了确认，但客户端却没有对服务器的起始序列号做确认，不能保证传输的可靠性。
2、防止失效的连接请求报文段被服务端接收，从而产生错误，浪费资源。

PS：失效的连接请求：若客户端向服务端发送的连接请求丢失，客户端等待应答超时后就会再次发送连接请求，此时，上一个连接请求就是"失效的"。

详细答案2（假设将3次握手综合为2次握手）

若建立连接只需两次握手，而客户端还是需要获得服务端的应答后才进入ESTABLISHED状态，服务端在收到连接请求后就进入ESTABLISHED状态。此时编程客户端发请求，服务端收到请求立刻变为ESTABLISHED状态，并返回确认请求，客户端收到后进入ESTABLISHED状态。

此时如果网络拥塞，客户端发送的连接请求迟迟到不了服务端，客户端便超时重发请求，如果服务端正确接收并确认应答，双方便开始通信，通信结束后释放连接。此时，如果那个失效的连接请求抵达了服务端，由于只有两次握手，服务端收到请求就会进入ESTABLISHED状态，等待发送数据或主动发送数据。但此时的客户端早已进入CLOSED状态，服务端将会一直等待下去，这样浪费服务端连接资源。

TCP的四次挥手可以3次或者5次吗？

在建立连接的时候,Server把响应客户端的请求和请求客户端的确认放在一起发送给客户端了,即第二次握手时有SYN+ACK

而断开连接的时候,一个方向的断开,只是说明该方向数据已传输完毕,而另一个方向或许还有数据,所以得等到另一个方向数据也全部传输完成后,才能执行第三次挥手，所以不能只进行三次挥手。

而4次挥手已经满足需求了，不需要再进行第五次挥手了，造成资源浪费。

JAVA的拷贝

1、循环拷贝

用一个for循环进行元素的逐个拷贝，是浅拷贝，拷贝速度比较慢。for(int i = 0;i < array1.length;i++){ array2[i] = array1[i]; }

2、System.arraycopy（浅拷贝）

这个是系统提供的拷贝方式，它是浅拷贝，也就是说对于非基本类型而言，它拷贝的是对象的引用，而不是去新建一个新的对象。System.arraycopy(array, 0, array2, 0, array.length);

3、Arrays.copyOf（浅拷贝）

array2 = Arrays.copyOf(array1,array1.length);

4、Object.clone

clone()比较特殊，对于对象而言，它是深拷贝，但是对于数组而言，它是浅拷贝。

对象拷贝：要调用这个方法，就需要我们写一个类，然后声明实现cloneable接口就好了，不需要去显示地声明继承于object

数组拷贝：array2=array1.clone(); 对于数组而言，它不是简单的将引用赋值为另外一个数组引用，而是创建一个新的数组。

JAVA的四种引用

1.强引用：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象

String str = new String("str");

这个str就是强引用。

2.软引用：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。

// 注意：wrf这个引用也是强引用，它是指向SoftReference这个对象的，
// 这里的软引用指的是指向new String("str")的引用，也就是SoftReference类中T
SoftReference<String> wrf = new SoftReference<String>(new String("str"));

可用场景：
创建缓存的时候，创建的对象放进缓存中，当内存不足时，JVM就会回收早先创建的对象。PS：图片编辑器，视频编辑器之类的软件可以使用这种思路。

3.弱引用：具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象

WeakReference<String> wrf = new WeakReference<String>(str);

Java源码中的java.util.WeakHashMap中的key就是使用弱引用

4。虚引用：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。

PhantomReference<String> prf = new PhantomReference<String>(new String("str"), new ReferenceQueue<>());

可用场景：
对象销毁前的一些操作，比如说资源释放等。Object.finalize()虽然也可以做这类动作，但是这个方式即不安全又低效

详细说明

堆和栈的区别

栈内存:栈内存首先是一片内存区域，存储的都是局部变量，凡是定义在方法中的都是局部变量（方法外的是全局变量），for循环内部定义的也是局部变量，是先加载函数才能进行局部变量的定义，所以方法先进栈，然后再定义变量，变量有自己的作用域，一旦离开作用域，变量就会被释放。栈内存的更新速度很快，因为局部变量的生命周期都很短。

堆内存:存储的是数组和对象（其实数组就是对象），凡是new建立的都是在堆中，堆中存放的都是实体（对象），实体用于封装数据，而且是封装多个（实体的多个属性），如果一个数据消失，这个实体也没有消失，还可以用，所以堆是不会随时释放的，但是栈不一样，栈里存放的都是单个变量，变量被释放了，那就没有了。堆里的实体虽然不会被释放，但是会被当成垃圾，Java有垃圾回收机制不定时的收取。

1.栈内存存储的是局部变量而堆内存存储的是实体；

2.栈内存的更新速度要快于堆内存，因为局部变量的生命周期很短；

3.栈内存存放的变量生命周期一旦结束就会被释放，而堆内存存放的实体会被垃圾回收机制不定时的回收。

UDP能否也像TCP那样安全，怎么做

模拟TCP的功能：

三次握手

四次挥手

发送端要带有计时器，要实现RTT估计和RTO（重传计时器）估计

可靠数据传输：发送端维护最早未被确认的字节序号（sendbase), 下一个要发送的字节的序号(nextSeqNum), 通过单一计时器来实现超时重传，通过冗余ACK来实现快速重传。
流量控制：有一个在任何时刻能保持的最大的未确认的《字节数》（最大窗口数），包能够有的最多字节数。
因为是在环回网络上测试，所以要模拟数据包出现TCP中的意外–丢失，延迟，损坏，乱序
接收端收到后立刻返回ACK。不对ACK包进行操作

模拟实现的过程如下

1、设计思路之包头设计

三次握手需要syn，ack两个标志位，四次挥手需要fin的标志位，校验错误需要crc码，传输数据需要ackNo码跟seqNo码。

2、设计思路之状态

class States(Enum):
CLOSE = 0
LAST_ACK = 1
SYN_RCVD = 2
SYN_SENT = 3
CLOSE_WAIT = 4
ESTABLISHED = 5
FIN_WAIT = 6

发送端发送第一次握手后进入SYN_SENT, 接收端接收后进入SYN_RCVD, 回复第二次握手，发送端接收后回复第三次握手，进入ESTABLISHED, 准备发送数据。接收端接收后进入ESTABLISHED等待数据。

3、快速重传
收到乱序包时，回复等待接收的正确顺序的那个ACK包。发送端收到3个同样的冗余ACK后就可以重传了。因此发送端需要维护一个缓冲区。里面存着已发送但还未确认的包。该缓冲区大小小于最大窗口数。

接受端
接收数据，要区分一下情况：

包丢失，即包的seq_num比last_ack_num大（last_ack_num:最后一个收到并确认的数据包的seq_num）
包重复，丢弃即可
包损坏，丢弃，当作没收到
包延时：先存后面的包，使用快速重传，回复冗余ACK
包乱序：同包延时处理

全局变量和局部变量变量名能否一样？

能。但是进行局部运算的时候，局部变量会屏蔽全局变量。

 Class A{int a = 1;                            //全局变量public static void main(String[] args){A c = new A();a = 2;                        //局部变量system.out.println(a);         //局部变量system.out.println(c.a);       //全局变量}
}

所以输出结果是：

Java实现一个算法，找出一个单链表中倒数第K个结点


LinkListNode nthToLast(LinkListNode head, int k)
{if( k<0 ) return null;LinkListNode p1 = head;LinkListNode p2 = head;//先将P2向前移动k个结点for(i = 0; i < k; i++){if (NULL == p2) return NULL;else p2 = p2->next;}if (NULL == P2) return NULL;//接着以同样的速度移动p1和p2，当p2抵达链表末尾时，p1指向第K个结点while(p2->next != NULL){p1 = p1->next;p2 = p2->next;}return p1;
}

ArrayList和LinkedList的大致区别：

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。（LinkedList是双向链表，有next也有previous）
2.对于随机访问get和set，ArrayList优于LinkedList，因为LinkedList要移动指针。

3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

4．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

5．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

6．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

常用的加密算法

1、DES加密算法

DES加密算法是一种分组密码，以64位为分组对数据加密，它的密钥长度是56位，加密解密用同一算法。

2、AES加密算法

AES加密算法是密码学中的高级加密标准，该加密算法采用对称分组密码体制，密钥长度的最少支持为128、192、256，分组长度128位，算法应易于各种硬件和软件实现。

3、RSA加密算法

RSA加密算法是目前最有影响力的公钥加密算法，并且被普遍认为是目前最优秀的公钥方案之一。RSA是第一个能同时用于加密和数宇签名的算法，它能够抵抗到目前为止已知的所有密码攻击，已被ISO推荐为公钥数据加密标准。

4、Base64加密算法

Base64加密算法是网络上最常见的用于传输8bit字节代码的编码方式之一，Base64编码可用于在HTTP环境下传递较长的标识信息。

5、MD5加密算法

MD5用的是哈希函数，它的典型应用是对一段信息产生信息摘要，以防止被篡改。

6、SHA1加密算法

SHA1是和MD5一样流行的消息摘要算法。SHA加密算法模仿MD4加密算法。SHA1设计为和数字签名算法（ＤＳＡ）一起使用。

7、XXXTEA加密算法

“微型加密算法（TEA）及其相关变种（XTEA，Block TEA，XXTEA）都是分组加密算法，它们很容易被描述，实现也很简单（典型的几行代码）。

硬链接和软连接

硬链接(hard link)：

　　　　A是B的硬链接（A和B都是文件名），则A的目录项中的inode节点号与B的目录项中的inode节点号相同，即一个inode节点对应两个不同的文件名，两个文件名指向同一个文件，A和B对文件系统来说是完全平等的。如果删除了其中一个，对另外一个没有影响。每增加一个文件名，inode节点上的链接数增加一，每删除一个对应的文件名，inode节点上的链接数减一，直到为0，inode节点和对应的数据块被回收。注：文件和文件名是不同的东西，rm A删除的只是A这个文件名，而A对应的数据块（文件）只有在inode节点链接数减少为0的时候才会被系统回收。

软链接(soft link)：

　　　　A是B的软链接（A和B都是文件名），A的目录项中的inode节点号与B的目录项中的inode节点号不相同，A和B指向的是两个不同的inode，继而指向两块不同的数据块。但是A的数据块中存放的只是B的路径名（可以根据这个找到B的目录项）。A和B之间是“主从”关系，如果B被删除了，A仍然存在（因为两个是不同的文件），但指向的是一个无效的链接。

主要区别、限制：

硬链接：

　　a.不能对目录创建硬链接，原因有几种，最重要的是：文件系统不能存在链接环（目录创建时的".."除外，这个系统可以识别出来）,存在环的后果会导致例如文件遍历等操作的混乱(du，pwd等命令的运作原理就是基于文件硬链接，顺便一提，ls -l结果的第二列也是文件的硬链接数，即inode节点的链接数)

　　b：不能对不同的文件系统创建硬链接,即两个文件名要在相同的文件系统下。

　　c：不能对不存在的文件创建硬链接，由原理即可知原因。

软链接：

　　a.可以对目录创建软链接，遍历操作会忽略目录的软链接。

　　b:可以跨文件系统

　　c:可以对不存在的文件创建软链接，因为放的只是一个字符串，至于这个字符串是不是对于一个实际的文件，就是另外一回事了

ln 语法格式

硬链接：ln 源文件链接名

软链接：ln -s 源文件链接名

注意： 链接的源文件路径要写绝对路径

外挂技术和反外挂技术

dobelee 2018-03-24 18:00:42 +08:00 via Android 4

外挂主要有三种
1.操作辅助型，如按键精灵
2.客户端篡改型，如非官方客户端
3.通讯篡改型，如抓取报文
反第三种最简单，加密通讯报文。
反第一种和第二种比较困难。

受制于网络延迟，FPS 游戏各种判定都是在客户端做的，所以目前反外挂很困难
至于外挂技术，无非就是突破驱动保护注入游戏篡改数据，反外挂就是检测有没有程序突破驱动保护篡改数据

1. 为了向性能妥协，大部分的验证都是在客户端校验的。服务端为了最快响应游戏数据，很少做反外挂处理。
2. 但是并不是完全不处理，据我所了解的，都是事后算账，定期清理一批数据异常的玩家，提升作恶成本，达到杀鸡儆猴足已。

腾讯怎么反外挂.

腾讯的 TP 一般就是通过驱动 HOOK 掉一些系统公开 /没公开的 API
例如读写内存的 API 通过驱动 hook 到自己程序中,对指定进程的内存读写进行屏蔽 /记录
比如 DEBUG 程序用到的一些关键性 API 通过驱动 hook 然后全局 anti-debug (不能调试任何程序,包括 DNF,JAVA,C++),导致用户无法 DEBUG 也就无法恢复这些 HOOK

hook 之后在通过一些黑科技防止用户恢复 hook,例如把一些参数通过奇怪的方式传到 API 中, 如果你没传 /传错了, 就会导致用户蓝屏
防止你加载各种驱动进入 R0 级别.

由于这种 hook 导致新更新大的系统版本的时候 TP 总是会导致蓝屏, 这也是没办法的,因为 hook 的很多 API 都不是微软提供开放使用的 API,所以版本更新调整一下 API 的参数结构什么的, TP 一 HOOK 就蓝屏也是很正常的

2.然后用心跳包之类的跟腾讯服务器进行沟通,发现 TP 被剥离游戏游戏立刻掉线

3.对主流的一些外挂进行特征码的记录, 可以不更新游戏进行对指定品牌的外挂进行封锁 . 但是外挂想绕过还是挺简单的,所以现在这外挂每天更新防止腾讯记录特征码

4.对一些不知名的 DLL 程序进行上传服务器鉴定,如果发现有问题,所有账号进行追封..

5.对虚拟机,IP 等检测如果有问题增加对检测的力度(主要针对工作室)

6.一般的动态 CRC,静态 CRC,CALL 检测,关键点 VM

7.其他一切未知的检测,不会让你知道你被没被检测,也许腾讯一直知道你在用挂,只不过现在还不想鸟你 ,只会在某个日子偷偷追封掉你的账号(最令人恶心的一个地方)

8.工作室行为检测针对用户 QQ 号游戏行为等等各种进行判断是否工作室 (估计内部是有账号评分系统, 分到某个阀值就触发封号机制.)

白盒测试

先讲一下，白盒测试其实应该是测试开发工程师，要懂代码，要看的懂代码层次的逻辑和架构，然后去寻找代码层次出现的bug问题，方法具体有：

语句覆盖，主要特点：语句覆盖是最起码的结构覆盖要求，语句覆盖要求设计足够多的测试用例，使得程序中每条语句至少被执行一次。

判定覆盖，主要特点：判定覆盖又称为分支覆盖，它要求设计足够多的测试用例，使得程序中每个判定至少有一次为真值，有一次为假值，即：程序中的每个分支至少执行一次。每个判断的取真、取假至少执行一次。

条件覆盖，主要特点：条件覆盖要求设计足够多的测试用例，使得判定中的每个条件获得各种可能的结果，即每个条件至少有一次为真值，有一次为假值。

判定/条件覆盖，主要点：设计足够多的测试用例，使得判定中每个条件的所有可能结果至少出现一次，每个判定本身所有可能结果也至少出现一次。

组合覆盖，主要特点：要求设计足够多的测试用例，使得每个判定中条件结果的所有可能组合至少出现一次。

路径覆盖，主要特点：设计足够的测试用例，覆盖程序中所有可能的路径。

从方法上不难看出如果测试人员不懂代码会给工作带来一定的压力，也正好的解释了第一章里最后问题，具体的也希望大家去进行一下自学。

当然我只是去罗列一下一些测试方法，百度也可得，我只是做了一下整理，真正变成自己的还需要去实践，当你自己去亲身测一段代码或者去测一测软件的某个功能，你就会去融会贯通。

职位要求：

1、作为游戏研发团队的坚强后盾，推进流程优化，评审设计文档，根据测试用例对产品进行模块测试和回归测试;

2、负责主导项目缺陷，对缺陷定位、提交、追踪、统筹管理以保证产品稳定性，推动提升产品质量;

3、探索业界先进的技术和工具，提高游戏的开发效率和品质;

4、与团队共同主导游戏产品开发中的技术、产品、流程的持续迭代与改进。