基础点收集

1.TCP协议的3次握手与4次挥手

TCP简介

TCP传输控制协议：罗伯特·卡恩（TCP/IP协议之父）
TCP负责监督传输的过程，一出现问题就发出信号，要求重新传输，直到所有数据安全正确的传输到目的地。

3次握手过程

所谓三次握手（Three-Way Handshake）即建立TCP连接，就是指建立一个TCP连接时，需要客户端和服务端总共发送3个包以确认连接的建立。在socket编程中，这一过程由客户端执行connect来触发，整个流程如下图所示：
1）第一次握手：
Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。
2）第二次握手：
Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。
3）第三次握手：
Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。
SYN攻击：
在三次握手过程中，Server发送SYN-ACK之后，收到Client的ACK之前的TCP连接称为半连接（half-open connect），此时Server处于SYN_RCVD状态，当收到ACK后，Server转入ESTABLISHED状态。SYN攻击就是Client在短时间内伪造大量不存在的IP地址，并向Server不断地发送SYN包，Server回复确认包，并等待Client的确认，由于源地址是不存在的，因此，Server需要不断重发直至超时，这些伪造的SYN包将产时间占用未连接队列，导致正常的SYN请求因为队列满而被丢弃，从而引起网络堵塞甚至系统瘫痪。SYN攻击时一种典型的DDOS攻击，检测SYN攻击的方式非常简单，即当Server上有大量半连接状态且源IP地址是随机的，则可以断定遭到SYN攻击了，使用如下命令可以让之现形：

#netstat -nap | grep SYN_RECV

4次挥手过程

三次握手耳熟能详，四次挥手估计就少有人知道了。所谓四次挥手（Four-Way Wavehand）即终止TCP连接，就是指断开一个TCP连接时，需要客户端和服务端总共发送4个包以确认连接的断开。在socket编程中，这一过程由客户端或服务端任一方执行close来触发，整个流程如下图所示
由于TCP连接时全双工的，因此，每个方向
都必须要单独进行关闭，这一原则是当一方完成数据发送任务后，发送一个FIN来终止这一方向的连接，收到一个FIN只是意味着这一方向上没有数据流动了，即不会再收到数据了，但是在这个TCP连接上仍然能够发送数据，直到这一方向也发送了FIN。首先进行关闭的一方将执行主动关闭，而另一方则执行被动关闭，上图描述的即是如此。
1）第一次挥手：
Client发送一个FIN，用来关闭Client到Server的数据传送，Client进入FIN_WAIT_1状态。
2）第二次挥手：
Server收到FIN后，发送一个ACK给Client，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号），Server进入CLOSE_WAIT状态。
3）第三次挥手：
Server发送一个FIN，用来关闭Server到Client的数据传送，Server进入LAST_ACK状态。
4)第四次挥手：
Client收到FIN后，Client进入TIME_WAIT状态，接着发送一个ACK给Server，确认序号为收到序号+1，Server进入CLOSED状态，完成四次挥手。
上面是一方主动关闭，另一方被动关闭的情况，实际中还会出现同时发起主动关闭的情况，具体流程如下图：
拓展：为什么建立连接是三次握手，而关闭连接却是四次挥手呢？
这是因为服务端在LISTEN状态下，收到建立连接请求的SYN报文后，把ACK和SYN放在一个报文里发送给客户端。而关闭连接时，当收到对方的FIN报文时，仅仅表示对方不再发送数据了但是还能接收数据，己方也未必全部数据都发送给对方了，所以己方可以立即close，也可以发送一些数据给对方后，再发送FIN报文给对方来表示同意现在关闭连接，因此，己方ACK和FIN一般都会分开发送。
以上摘自知乎，链接：https://zhuanlan.zhihu.com/p/22639051

2.Java中的克隆

Java中的克隆分为两种，一种是浅克隆（浅复制），另外一种是深克隆（深复制）

1.浅克隆：

创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。

1）定义一个student类，并实现Cloneable接口（teacher类同student相同，不贴代码）

java
//克隆的对象必须实现Cloneable这个接口，而且需要重写clone方法 public class Student implements Cloneable {

    private int age;
    //定义为private说明这个成员变量只能被被当前类中访问，如果外部需要获得，那么就只能通过getAge方法进行获取     private String name;

    private Teacher teacher;
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name) &&
                Objects.equals(teacher, student.teacher);
    }
    @Override
    public int hashCode() {

        return Objects.hash(age, name, teacher);
    }
    @Override
    public Object clone() throws CloneNotSupportedException
    {
        Object object = super.clone();
        return object;
    }
}

2）创建一个调用的测试类：

public class Demo {

    public static void main(String[] args) {
        try{
            Student student = new Student();
            student.setAge(18);
            student.setName("这就是我");
            Teacher teacher = new Teacher();
            teacher.setAge(55);
            teacher.setName("我是老师");
            student.setTeacher(teacher);
            Student student2 = (Student)student.clone();
            //这个是调用下面的那个方法，然后把这个这个对象Clone到student
            System.out.println("Age:" + student2.getAge() + " " + "Name:" + student2.getName());
            student.setName("我还是那个我");
            teacher.setName("我还是那个老师");
            System.out.println("teacherName:"+student2.getTeacher().getName());
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("报错了");
        }
    }
}

3）通过上面的代码，我们可以得到我们上面对“浅克隆”的描述，指向原有的内存地址。结果如下：

我们通过对上面的student中的属性先进行赋值，然后进行clone，然后在重新为teacher中的name赋值，为student中的name赋值，我们得到上面的结果“非基本类型属性，还是指向原来的内存地址”，这样会导致我们在使用过程中出现数据错乱的情况。

2.深克隆：

创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

1）还是创建上面的student类，只是重写上面的clone()方法（这里只贴重写的clone方法）

@Override
    public Object clone() throws CloneNotSupportedException
    {
        Student o = null;
        try {
            o = (Student) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.toString());
        }
        o.teacher = (Teacher) teacher.clone();
        return o;
    }

2）创建一个调用的测试类（这里只贴main()方法）

public static void main(String[] args) {

        try{
            Student student = new Student();
            student.setAge(18);
            student.setName("这就是我");
            Teacher teacher = new Teacher();
            teacher.setAge(55);
            teacher.setName("我是老师");
            student.setTeacher(teacher);

            Student student2 = (Student)student.clone();
            student.setName("我还是那个我");
            teacher.setName("我还是那个老师");
            System.out.println("Age:" + student2.getAge() + " " + "Name:" + student2.getName());
            System.out.println("teacherName:"+student2.getTeacher().getName());
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("报错了");
        }
    }

我们还是进行浅克隆中的赋值操作，克隆完成后，对原对象进行赋值，修改源对象的内容，但是我们会发现，我们得到的结果没有发生变化，下面是操作结果

总结：
实现Cloneable接口并重写clone接口只能进行浅克隆。但是如果类的引用类型属性（以及属性的引用类型属性）都进行浅克隆，直到没有引用类型属性或者引用类型属性为null时，整体上就形成了深克隆。既对象的引用类型属性和属性的应用类型属性都实现Coloneable，重写clone方法并在clone方法中进行调用。
在选择深克隆方法时，应根据对象的复杂成都，如引用类型属性是否有多层引用类型属性关系。如果对象只有一层或者两层引用类型的属性，选择上面提到的方法较为方便，反之则使用对象流。
以上摘自知乎，链接：https://zhuanlan.zhihu.com/p/70690922

3.池化思想

说到池我们很容易想到水池，那么水池的作用是什么?
当然是蓄水，我们以多人排队取水为例
单线程的方式：大家排队一个一个取水，为了不浪费水，每个人接完水后，关掉水龙头，下一个人接的时候再打开水龙头，开水龙和关水龙头可以看成创建和销毁一个线程用于一个人的取水任务。这种方式适合人少的场景。　　　　　
多线程的方式：多提供几个水龙头，这种方式适合人较多的场景，例如学生宿舍的公共水房。
线程池的方式：提供一个水池，先将水放到水池，然后由多个人同时在水池取水，水龙头可以不用频繁开关，可以支持多人并发取水，但是水池需要专人监管，如监控水池溢出，水池没水，水池取水人员达到上限等。这种方式适合高并发的情况。
　　当高并发的时候，不可小看关水龙头和开水龙头带来的时间浪费，也可理解为线程的系统开销，由此看来池化思想最大的作用是支持复用， 避免重复的创建销毁带来的开销。
分析：池化思想是我们项目开发过程中的一种非常重要的思想，如整数池，字符串池，对象池、连接池、线程池、数据库连接池、Java常量池、NAT公网地址池等都是池化思想的一种应用，都是通过复用对象，以减少因创建和释放对象所带来的资源消耗，进而来提升系统性能。例如Integer对象的内部池应用，代码如下：

package com.cy.java.pool;
public class TestInteger01 {
    public static void main(String[] args) {
        Integer n1=100;//Integer.valueOf(100) 编译时优化
        Integer n2=100;
        Integer n3=200;
        Integer n4=200;//池中没有则new Integer(200)        System.out.println(n1==n2);//true      System.out.println(n3==n4);//false 
    }    
}