招商银行软件开发笔试知识汇总

Thread

start(): 将线程由New状态变为ready状态，一个线程只能调用一次start（），start（）方法的被调用顺序不能决定线程的执行顺序
run():用start方法启动线程是并发执行的，输出结果不是固定的，因为线程的运行没法预测。而用run方法启动线程，run方法只是一个普通方法，是不能实现并发的，实际上还是线性执行
参考：并发基础篇（六）：线程Thread类的start()方法和run()方法

数组指针

对数组名取地址得到指向整个数组的指针，&a是数组指针，其类型为int()[5];而指针加1要根据指针类型加上一定的值，不同类型的指针+1之后增加的大小不同，a是长度为5的int数组指针，所以要加5sizeof(int)，加1指向整个数组之后的内存空间，再减1就指向数组的最后一个元素5

int a[10]; a就相当于int *，如果是对它加1（a + 1）是相当于a + 1 * sizeof(int)。但是&a的类型则相当于int **，是所谓指向数组的指针，是数组元素类型的二级指针，对它加1是相当于 &a + 1 * sizeof(a)的，所以会偏移一个数组长度。
##数据类型所占的存储空间
一般32位机子上各个数据类型所占的存储空间如下：
char：8位
short：16位
int：32位
long：32位
float：32位
double：64位

牢记以下3条原则：（在没有#pragma pack宏的情况下）

struct，结构体对齐

1、数据成员对齐规则：结构体（struct）的数据成员，第一个数据成员放在offset为0的地方，之后的每个数据成员存储的起始位置要从该成员大小的整数倍开始（比如int在32位机子上为4字节，所以要从4的整数倍地址开始存储）。

2、结构体作为成员：如果一个结构体里同时包含结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（如struct a里有struct b,b里有char,int ,double等元素，那么b应该从8(即double类型的大小)的整数倍开始存储）。

3、结构体的总大小：即sizeof的结果。在按之前的对齐原则计算出来的大小的基础上，必须还得是其内部最大成员的整数倍，不足的要补齐（如struct里最大为double，现在计算得到的已经是11，则总大小为16）。
typedef struct bb
{
int id; //[0]…[3] 表示4字节
double weight; //[8]…[15]　　　　　　原则1
float height; //[16]…[19],总长要为8的整数倍,仅对齐之后总长为[0]~[19]为20，补齐[20]…[23]　　　　　原则3
}BB;
size为56

sizeof(Union)
在union中，所有的共用体成员共用一个空间，并且同一时间只能储存其中一个成员变量的值。当一个共用体被声明时, 编译程序自动地产生一个变量, 其长度为联合中元类型（如数组，取其类型的数据长度）最大的变量长度的整数倍，且要大于等于其最大成员所占的存储空间。
union foo
{
char s[10];
int i;
}
在这个union中，foo的内存空间的长度为12，是int型的3倍，而并不是数组的长度10。若把int改为double，则foo的内存空间为16，是double型的两倍。

union mm{
char a;//元长度1 1
int b[5];//元长度4 20
double c;//元长度8 8
int d[3]; 12
};

所以sizeof(mm)=8*3=24；

参考：大荣qhr

父类子类执行顺序

父类静态代码块 --> 子类静态代码块 --> 父类无参构造方法 --> 子类无参构造方法
且静态代码块在初始化时仅执行一次
对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序依次是（静态变量、静态初始化块）>（变量、初始化块）>构造器。看代码：`链接：

public class InitialOrderTest {
// 静态变量
public static String staticField = “静态变量”;
// 变量
public String field = “变量”;
// 静态初始化块
static {
System.out.println(staticField);
System.out.println(“静态初始化块”);
}
// 初始化块
{
System.out.println(field);
System.out.println(“初始化块”);
}
// 构造器
public InitialOrderTest() {
System.out.println(“构造器”);
}
public static void main(String[] args) {
new InitialOrderTest();
}
}`

结果：1. 静态变量 2. 静态初始化块 3. 变量 4. 初始化块 5. 构造器

对于继承情况下的类的初始化是怎样的呢？看代码：`

class Parent {
// 静态变量
public static String p_StaticField = “父类–静态变量”;
// 变量
public String p_Field = “父类–变量”;
// 静态初始化块
static {
System.out.println(p_StaticField);
System.out.println(“父类–静态初始化块”);
}
// 初始化块
{
System.out.println(p_Field);
System.out.println(“父类–初始化块”);
}
// 构造器
public Parent() {
System.out.println(“父类–构造器”);
}
}
public class SubClass extends Parent {
// 静态变量
public static String s_StaticField = “子类–静态变量”;
// 变量
public String s_Field = “子类–变量”;
// 静态初始化块
static {
System.out.println(s_StaticField);
System.out.println(“子类–静态初始化块”);
}
// 初始化块
{
System.out.println(s_Field);
System.out.println(“子类–初始化块”);
}
// 构造器
public SubClass() {
System.out.println(“子类–构造器”);
}
// 程序入口
public static void main(String[] args) {
new SubClass();
}
}`
结果：

1. 父类--静态变量
2. 父类--静态初始化块
3. 子类--静态变量
4. 子类--静态初始化块
5. 父类--变量
6. 父类--初始化块
7. 父类--构造器
8. 子类--变量
9. 子类--初始化块
10. 子类--构造器

可以注意到一点，并不是父类完全初始化完毕后才进行子类的初始化，实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。
那么对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢？是否静态变量总是先于静态初始化块，变量总是先于初始化块就被初始化了呢？实际上这取决于它们在类中出现的先后顺序。
参考：饭特稀233

sleep() wait()

sleep()是Thread类的方法，wait()是对象类的方法
sleep不释放对象锁，wait放弃对象锁；
sleep暂停线程、但监控状态仍然保持，结束后会自动恢复；

Linux多进程

在Linux上，对于多进程，子进程继承了父进程的
用户号UIDs和用户组号GIDs
环境Environment
堆栈
共享内存
打开文件的描述符
执行时关闭（Close-on-exec）标志
信号（Signal）控制设定
进程组号
当前工作目录
根目录
文件方式创建屏蔽字
资源限制
控制终端

子进程独有
进程号PID
不同的父进程号
自己的文件描述符和目录流的拷贝
子进程不继承父进程的进程正文（text），数据和其他锁定内存（memory locks）
不继承异步输入和输出

父进程和子进程拥有独立的地址空间和PID参数。

数据库锁

数据库系统锁分为独占锁、共享锁和更新锁三种
行级锁在多线程中相比页级锁更不容易产生锁定冲突

tcp udp

TCP提供一种面向连接的、可靠的字节流服务
TCP 协议声称可靠性数据传输，其底层实现机制主要包括三个方面：使用序列号对传输的数据进行编号，数据超时重传，数据确认应答
两个使用TCP的应用（通常是一个客户和一个服务器）在彼此交换数据之前必须先建立一个TCP连接
UDP在实际中有很多方面的应用，如广播和多播

java中接口和抽象类的区别?

1、接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
2、类可以实现很多个接口，但是只能继承一个抽象类。
3、如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。
4、抽象类可以在不提供接口方法实现的情况下实现接口。Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
5、Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。
6、接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。

数据库的并发

并发：在单处理机上，利用分时方法实行多个事务同时做。
数据库的并发操作是：许多事务对同一数据进行操作。带来的问题：1、丢失更新问题；2、读脏数据问题；3、不可重复读问题；
解决这些问题：封锁技术。

strcpy函数重载

char* strcpy(char* dst,const char* src){
if(NULL == dst || NULL == src)
return dst;
char* strDst = dst;
while(*src != '\0'){
*dst++ = *src++;
}

*dst = '\0';
return strDst;
}