计算机基础复习12.25

字节流：以字节为单位读写数据，主要用于处理二进制数据，如音频，图像文件等

字符流：以字符为单位读写数据，主要用于处理文本数据

在大文本文件中查找某个字符串，可以直接通过字符流来读取判断

处理视频文件时，通常使用字节流FileInputStream,FileOutputStream来读取或写入数据，并且会尽量使用缓冲流BufferedInputStream来提高读写效率

用户态和内核态区别

内核态：在内核态下，CPU可以执行所有的指令和访问所有的硬件资源，这种模式下的操作具有更高的权限，主要用于操作系统内核的运行

用户态：在用户态下，CPU只能执行部分指令集，无法直接访问硬件资源，这种模式下的操作权限比较低，主要用于用户程序

设计原则

开闭原则：对扩展开放，对修改关闭

里氏替换原则：程序中的父类都可以正确的被子类型替换

依赖倒置：模块之间交互应该依赖于抽象，而非实现

单一职责：对任何类的修改只能有一个原因

接口隔离：客户端对类的依赖基于最小接口，而不依赖于不需要的接口

迪米特法则：一个类对于其他类知道的越少越好

合成复用原则：优先使用合成/聚合，而不是类继承

==和equals()的区别

== 对于基本数据类型，==比较的是值，对于引用数据类型，比较的是对象的内存地址

equals()不能用于判断基本数据类型的变量，如果没有重写equals方法，通过equals比较该类的两个对象，等价于==比较这两个对象

类重写equals方法，重写equals方法来比较两个对象的属性是否相等，若属性相等，则返回true

MVC: model(模型)-视图(view)-控制器(controller)

视图：为用户提供使用界面，与用户直接进行交互

模型：一个存取数据的对象 java对象

控制器：将用户请求转发给相应的model进行处理

第一范式 1NF 属于第一范式关系的所有属性都不可再分，即数据项不可分

第二范式 2NF 若某关系R属于第一范式，且每一个非主属性完全函数依赖于任何一个候选码，则关系R属于第二范式

第三范式3NF 非主属性即不传递依赖于码，也不部分依赖于码

线程创建的方式有

继承Thread类：用户自定义继承java.lang.Thread类，重写其run方法，run方法中定义了线程执行的具体任务，创建该类的实例后，通过start()方法启动线程

实现runnable接口：如果一个类已经继承了其他类，就不能再继承Thread类，此时可以实现java.lang.Runnable接口，重写run方法

实现callable接口：callable的call方法可以有返回值并且可以抛出异常，要执行callable任务，需将它包装一个FutureTask。

completableFuture 有一个任务失败，使用whenComplete方法可以在任务完成时触发回调函数，并正确地处理异常，而不是让异常被吞噬或丢失

exceptionally方法可以处理异常并重新抛出，以便异常能够传播到后续阶段，而不是让异常被忽略或终止

使用handler方法可以处理正确的返回结果和异常，并返回一个新的结果，而不是让异常影响正常的业务逻辑

使用completableFuture.allOf方法可以组合多个CompletableFuture,并将统一处理所有任务的异常，而不是异常处理过于冗长或重复。

mq保证消息可靠性

生产者到MQ  采用confirm机制 

rabbitMQ自身：采用持久化

rabbitMQ到消费者：basicACK机制，死信队列，消息补偿

canal模拟mysql主从复制的交互协议，把自己伪装成一个mysql的从节点，向mysql主节点发送dump请求，mysql收到请求后，就会开始推送binlog给canal，canal解析binlog字节流之后，转换为便于读取的结构化数据，供下游程序订阅使用

抽象类和接口的适用场景

需要有默认实现

想要多重继承

进程间的通信方式

1.管道  管道传输数据是单向的，管道这种通信效率很低，不适合进程间频繁交换数据

2.消息队列 保存在内核中的消息链表，在发送数据时，会分成一个一个独立的数据单元

3.共享内存：拿出一块虚拟地址空间来，映射到相同的物理内存中

4.信号量：是一个整型的计数器，主要用于实现进程间互斥与同步，而不是用于缓存进程间通信的数据

使用ReentLock实现交替打印奇数偶数

public class Demo {
    private static Lock lock=new ReentrantLock();
    private static Condition A= lock.newCondition();
    private static Condition B=lock.newCondition();
    private static int count=0;

    static class ThreadA extends Thread{
        @Override
        public void run(){
            while(count<10){
                lock.lock();
                try {

                    if(count%2==0){
                        System.out.println(Thread.currentThread().getName()+" "+count);
                        count++;
                        B.signal();
                    }else{
                        A.await();
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }finally{
                    lock.unlock();
                }

            }
        }
    }
    static class ThreadB extends Thread{
        @Override
        public void run(){
            while(count<10){
                lock.lock();
                try {

                    if(count%2!=0){
                        System.out.println(Thread.currentThread().getName()+" "+count);
                        count++;
                        A.signal();
                    }else{
                        B.await();
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }finally {
                    lock.unlock();
                }

            }
        }
    }
    public static void main(String[]args){
        new ThreadA().start();
        new ThreadB().start();
    }
}