一段时间的随笔总结（redis，hibernate，高并发）

对于redis的总结：

 

redis缓存数据，应用于减少系统对于io，对于数据库，对于文件的访问，提高响应。

redis使用 key-value的方式进行数据的存储，以区分于关系型数据库

redis可以存储5中类型的数据 包括 String List HashMap Set ZSet(有序集合)

redis使用 set-get push-pop等方式进行数据的存储和获取

 

 

redis的注意事项：

（1）从数据存储方面（内存有限）：

a.对key使用简写

b.对于大型的存储文件适应压缩后在存储

c.redis内部有一个0-9999的整数池，共享value。

d.对于众多的String类型的储存，使用hash的方式进行存储，减少key的消耗

（2）数据查询：

a.redis也是一种数据库，因此需要使用连接对象，对象的建立和销毁都需要资源，因此当使用连接池的方式使用连接对象

b.如果一次业务中多次对redis进行查询，可以将多次查询合并，节省时间和资源消耗

 

 

redis的存储方式：2种（RDB和AOF）

RDB的方式是将数据保存到临时文件中，当文件备份完成，则替代源文件

AOF的方式是将写命令在文件的最后添加，当文件添加到一定程度（上一次重写的百分之几的时候）就会进行一次重写（重写前可以撤销之前的命令）

RDB和AOF的对比：

1.RDB实在规定的时间使用fork子线程备份，本地只有一个文件，如果系统出现灾难，可以很好的复原，

2.速度快，因为是分出一个子线程去完成持久化操作，因此不会阻塞主线程,他只存数据，不存命令

3.相对于AOF方式如果数据集大的话，能够更快的启动

劣势：1.因为RDB是隔一段时间持久化一次，如果出现系统崩溃，则可能出现数据丢失的情况

2.由于是通过fork子线程来持久化，当数据集大的时候，可能会出现卡1毫秒的情况

 

AOF机制有三种持久化策略：每秒同步，修改同步，和不同步

1.每秒同步也是异步持久化，因此效率也不错，但是修改同步则是效率很低的

2.因为使用append的方式持久化，当持久化到一半时，系统宕机，可以通过redis-check-aof解决数据一致性问题

3.如果日志过大，则会自动启动重写机制

4.因为是记录每次的修改命令，所以可以很好的复原操作过程

缺点：1.AOF的效率明显比RDB慢，（同步禁用的策略则相差不多）

2.对于相同的数据，AOF的文件比RDB大，启动的时候也相对较慢

 

redis么默认使用RDB方式存储，如果要使用AOF方式，则要修改配置文件redis.conf：appendonly yes

 

 

高并发

对于数据库：

1.使用缓存，不从数据库取资源，而是从缓存取，当进行修改操作的时候，再同步缓存或者隔一段时间同步缓存（加锁并避免所有缓存同时间更新，导致缓存击穿）

2.分库分表分区操作

3.主从同步与读写分离：使用master和slave进行主从复制，master写并将更新写入二进制记录文件中，slave数据库负责读，并查询二进制记录文件，当查询到发生改变时，发起复制，封锁主数据库，当复制完成，释放锁。

 

对于web服务器：使用负载均衡策略和消息中间件，实现请求的串行和平衡

对于前端页面：使用静态页面技战术（freemarker）生成html页面再需要真实数据时（使用ajax等异步请求）

对于数据，通过合并文件，压缩文件上实现速度的提升

 

 

hibernate与mybatis的区别

1.hibernate 对于单表的dao层要比mybatis简单，mybatis需要维护sql和结果映射

2.hibernate对对象的维护和缓存比mybatis好，对单表的增删改查要简单

3.hibernate有自己HQL语句，移植性更好，而mybatis则不同，依赖于不同的数据库语句

4.mybatis只需要统一的sql语句，更易掌握

5.mybatis可以优化sql语句和反射集合（多表查询更好）

 

 

Socket

TCP/IP UDP

TCP/IP 是传输控制协议/网间协议

UDP 与TCP相对应的协议

他们之间的关系：

而socket套接字的位置：

 

 

 

 

socket的基本流程：

 

 

TCP三次握手：

第一次 客户端向服务器端发送握手请求：

第二次 服务器端接收到客户端的请求后，向客户端发送请求：你可以链接

第三次 客户端发送请求连接，并带一小部分数据

 

TCP四次挥手：

第一次：客户端向服务器端发送请求，请求断开连接

第二次 : 服务器端向客户端发送请求 确认客户端是否要断开并告知我知道了

第三次：服务器端向客户端发送请求，要断开（客户端断开）

第四次：客户端向服务器端发送请求，断开了，然后服务器端断开

 

 

JMM

 

JMM（java内存模型）是一种共享内存模型，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存中，每个线程都有一个本地的私有内存，本地内存中存储了该线程以读写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它覆盖了缓存，写缓冲区，寄存器以及其他硬件和编译器优化

 

 

JMM带来的问题：

可见性问题：使用volatile关键字或者锁

竞争问题：锁或者synchronized关键字

 

在执行程序时，为了提高性能，编译器和处理器常常会重排序指令

编译器重排序:编译器在保证单线程语义不变的情况下，重新安排语句的执行顺序

处理器重排序：将多条指令重叠执行，如果不存在数据依赖性，处理器可以改变指令的执行顺序，

内存的重排序：由于处理器使用读写缓冲区和缓存，所以加载和存储看起来混乱

 

重排序会使数据的依赖性和 控制依赖性发生变化，使执行结果一致性发生错误，因此要遵循 as-if-serial语义(即无论怎么重排序，不会对数据依赖性和控制依赖性发生改变，禁止会发生改变的重排序)

 

禁止重排序的方式 volatile和 lock synchronized关键字

volatile能保证共享变量的可见性，保证单个读写操作的原子性，复合型的读写操作的原子性不保证

lock 和 临界区（synchronized）则会保证共享变量的原子性和可见性

 

synchronized的原理

使用monitorenter和monitorexit指令实现的：

• monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处
• 每个monitorenter必须有对应的monitorexit与之配对
• 任何对象都有一个monitor与之关联，当且一个monitor被持有后，它将处于锁定状态

 

synchronized的优化：

4种锁： 无锁状态，偏向锁，轻量锁，重量锁

 

偏向锁，大多数情况下，锁不存在竞争，总是由同一个线程获取锁，为了使获取锁的代价更加的低从而引入了偏向锁，无竞争下，不需要CAS来进行加锁和解锁

轻量锁：无竞争时使用CAS在进行枷锁和解锁 （独占锁和共享锁）

重量级锁（synchronized）真正加锁

 

AQS：

AQS是指AbstractQueuedSynchronizer类

ReentrantLock将所有的Lock接口的操作都委派到一个Sync类上，该类继承了AQS

AQS是管理锁的抽象类，抽象所大部分锁的方法，只把tryAcquire方法延迟到子类实现，AQS使独占锁（reentrantLock）和共享锁（信号量，共享工具类，读写锁）的公共父类，AQS通过CAS实现

（1）独占锁，所在同一时段只能被一个线程占有，而根据锁的获取机制，又分为公平锁和非公平锁，公平锁通过CLH线程队列 按照FIFO的原则，公平的获取锁，而非公平锁则是队列中的锁都去竞争锁（独占锁包括： ReentrantLock和 读写锁中的写锁）

（2）共享锁，被多个线程共同占有，包括 共享工具类（CountDownLacth ， 信号量，CyclicBrrier，读写锁中的读锁）

 

在AQS中未获取到锁的线程 通过自旋CAS 得知自己的状态和是否该去获取锁

独占锁在自旋时同时会获取自己是否为等待队列的首节点，一边去获取锁

 

CountDownLacth 是 等待所有线程（他规定的线程个数）都运行完成 再使主线程运行（和join方法类似，但比join方法速度快）

CyclicBrrier 是 所有线程都运行到屏障时等待，当所有的线程都运行到的时候在运行下去（可重用，比countDownLacth好）

信号量（SemaPhore）控制并发线程数，只有使用 信号量的 acquire方法获取到信号量才能运行同步代码，release释放信号量

线程间交换数据（Exchanger） 2只有2个线程都运行了exchange方法后才能执行下去，要不然先运行到exchange的线程阻塞。