一、集成redis
 
1、引入redis的依赖
 
 		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

 
2、yml中配置redis地址、端口、密码
 
redis:
    # redis密码
    password:
    alone:
      #redis地址
      host: 127.0.0.1
      #redis端口
      port: 6379

 
3、在server中使用redis
 
首先实体类要实现序列化
 
 
简单实现redis缓存和查询功能
 
@Service
public class SysUserService {
	//自动注入redis
	@Autowired
    private RedisTemplate<Object,Object> redisTemplate;

	//根据用户id获取用户信息
	 public SysUser selectSysUserByUserId(Integer userId){
        //修改key的序列化类型 提高可读行 StringRedisSerializer设置key的类型为string
        RedisSerializer redisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(redisSerializer);

        //从redis缓存中查询
        SysUser sysUser = (SysUser) redisTemplate.opsForValue().get("sysUser");
        //如果为空则从数据库查询
        if(sysUser == null){
            //从数据库查询
             sysUser = sysUserDao.selectSysUserByUserId(userId);
             //存入redis中
             redisTemplate.opsForValue().set("sysUser",sysUser);
        }
        return sysUser;
    }
}

 
解决高并发问题
 
第一种：效率最慢。在方法前面加上synchronized ，使用同步锁去锁定请求。当同时有一千条数据请求时，只能一条一条请求的进来。
 
 public synchronized SysUser selectSysUserByUserId(Integer userId){
        //修改key的序列化类型 提高可读行 StringRedisSerializer设置key的类型为string
        RedisSerializer redisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(redisSerializer);

        //从redis缓存中查询
        SysUser sysUser = (SysUser) redisTemplate.opsForValue().get("sysUser");
        if(sysUser == null){
            //从数据库查询
             sysUser = sysUserDao.selectSysUserByUserId(userId);
             redisTemplate.opsForValue().set("sysUser",sysUser);
        }
        return sysUser;
    }
 
第二种：效率比第一种高点，可以适用请求量不大的场景下。
 
 public  SysUser selectSysUserByUserId(Integer userId){
        //修改key的序列化类型 提高可读行 StringRedisSerializer设置key的类型为string
        RedisSerializer redisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(redisSerializer);

        //从redis缓存中查询
        SysUser sysUser = (SysUser) redisTemplate.opsForValue().get("sysUser");

        //双重监测锁
        if(sysUser == null){
            synchronized (this){
                if(sysUser == null){
                    //从数据库查询
                    sysUser = sysUserDao.selectSysUserByUserId(userId);
                    redisTemplate.opsForValue().set("sysUser",sysUser);
                }
            }
        }

        return sysUser;
    }

吐槽
 
平时多积累点高并发啊锁啊缓存啊这些知识点
 
面试的时候可以和面试官侃侃而谈
 
面试官喜欢听高并发相关的
 
当然你能结合实际业务场景来分析
 
面试肯定加分
 
 
 
 
 
传统单点应用的线程安全问题，因为只涉及到单个应用中多线程之间的资源共享，往往通过加锁synchronized，ReentrantReadWriteLock等手段就能实现共享资源的安全；
 
但是现在很多大型系统，高并发的量往往较大，整个服务架构也都是设计成分布式架构，原本在单机中的共享资源转而分布在了不同的机器上，这个时候锁也应该相应的升级为分布式锁；
 
分布式锁有多种方式redis，zookeepper等，因为系统中本就用到了redis，就以redis为例：
 
分布式锁需要满足什么条件呢？
 
一，互斥：既然是锁，不能每个客户端都有吧，那还锁啥？
 
二，不能死锁：让一个客户端抱住锁，永远不释放，别的就获取不到了，那还要分布式系统干啥？
 
三，每个客户端的锁自己加，自己解；
 
redis为什么能作为分布式锁的选择呢？本身就是单进程单线程的模式，并且提供的命令具有原子性；
 
一般用来做分布式锁的方式有1，setnx+getset方式， 2，INCR
 
1，setnx+getSet方法加锁：
 
setnx：（set if not exists）不存在就设置，设置成功为1，已经存在，返回0；
 
getSet: set新key，并返回原来的value；
 
伪代码如下图：
 
 
场景解释如下：
 
第一个线程读到没有锁存在，使用lock加锁，带上时间戳，超时则释放锁，防止死锁
 
第二个线程读到锁存在（setnx==0）,进入循环，判断锁是否在超时时间内，并使用setGet方法把最新的超时时间set进去，（防止超时时间到了，多个线程读到锁超时，都去释放的情况），
 
第一个线程处理完业务逻辑，并删除锁，则后面的线程可以获得锁。。。
 
2，INCR方法加锁
 
这个方法会在不存在key的时候，先初始化0，然后加1，返回1；如果key存在，则在执行就会大于1；
 
所以使用INCR方法加锁，伪代码如下图：
 
 
1，进行加锁操作；
 
2，如果锁不存在，并且加锁成功，设置过期时间；
 
3，如果锁已经存在，查看是否已经过了过期时间，如果过了，则重新设置。。
 
当然上述的分布式锁只在单机redis中安全，如果存在redis集群，可能会因为宕机，延时等问题，让锁不在唯一。需要redis官方推荐的redlock进行加锁，对此reddssion已经有良好的封装RedissionLock，建议可直接使用。
 
 
 

Redis锁解决高并发问题
 
redis真的是一个很好的技术，它可以很好的在一定程度上解决网站一瞬间的并发量，例如商品抢购秒杀等活动。
 redis之所以能解决高并发的原因是它可以直接访问内存，而以往我们用的是数据库(硬盘),提高了访问效率,解决了数据库服务器压力。
 
为什么redis的地位越来越高，我们为何不选择memcache，这是因为memcache只能存储字符串，而redis存储类型很丰富（例如有字符串、LIST、SET等），memcache每个值最大只能存储1M,存储资源非常有限,十分消耗内存资源。
 而redis可以存储1G,最重要的是memcache它不如redis安全,当服务器发生故障或者意外关机等情况时,redsi会把内存中的数据备份到硬盘中,而memcache所存储的东西全部丢失;这也说明了memcache不适合做数据库来用,可以用来做缓存。
 
这里我们主要利用Redis的setnx的命令来处理高并发。
 setnx 有两个参数。第一个参数表示键。第二个参数表示值。如果当前键不存在，那么会插入当前键，将第二个参数做为值。返回 1。如果当前键存在，那么会返回0。
 
创建库存表
 
CREATE TABLE `storage` (
 `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
 `number` int(11) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1
 
设置初始库存为10
 
创建订单表
 
CREATE TABLE `order` (
 `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
 `number` int(11) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1
 
测试不用锁的时候
 
$pdo = new PDO('mysql:host=127.0.0.1;dbname=test', 'root', 'root');
$sql="select `number` from storage where id=1 limit 1";
$res = $pdo->query($sql)->fetch();
$number = $res['number'];
if($number>0)
{
 $sql ="insert into `order` VALUES (null,$number)";

 $order_id = $pdo->query($sql);
 if($order_id)
 {

 $sql="update storage set `number`=`number`-1 WHERE id=1";
 $pdo->query($sql);
 }
}
 
ab测试模拟并发，发现库存是正确的。
 
mysql> select * from storage;
+----+--------+
| id | number |
+----+--------+
| 1 | 0 |
+----+--------+
1 row in set (0.00 sec)
 
在来看订单表
 
mysql> select * from `order`;
+----+--------+
| id | number |
+----+--------+
| 1 | 10 |
| 2 | 10 |
| 3 | 9 |
| 4 | 7 |
| 5 | 6 |
| 6 | 5 |
| 7 | 5 |
| 8 | 5 |
| 9 | 4 |
| 10 | 1 |
+----+--------+
10 rows in set (0.00 sec)
 
发现存在几个订单都是操作的同一个库存数据，这样就可能引起超卖的情况。修改代码加入redis锁进行数据控制
 
<?php

class Lock
{
 private static $_instance ;
 private $_redis;
 private function __construct()
 {
 $this->_redis = new Redis();
 $this->_redis ->connect('127.0.0.1');
 }
 public static function getInstance()
 {
 if(self::$_instance instanceof self)
 {
  return self::$_instance;
 }
 return self::$_instance = new self();
 }

 /**
 * @function 加锁
 * @param $key 锁名称
 * @param $expTime 过期时间
 */
 public function set($key,$expTime)
 {
 //初步加锁
 $isLock = $this->_redis->setnx($key,time()+$expTime);
 if($isLock)
 {
  return true;
 }
 else
 {
  //加锁失败的情况下。判断锁是否已经存在，如果锁存在切已经过期，那么删除锁。进行重新加锁
  $val = $this->_redis->get($key);
  if($val&&$val<time())
  {
  $this->del($key);
  }
  return $this->_redis->setnx($key,time()+$expTime);
 }
 }


 /**
 * @param $key 解锁
 */
 public function del($key)
 {
 $this->_redis->del($key);
 }

}



$pdo = new PDO('mysql:host=127.0.0.1;dbname=test', 'root', 'root');
$lockObj = Lock::getInstance();
//判断是能加锁成功
if($lock = $lockObj->set('storage',10))
{
 $sql="select `number` from storage where id=1 limit 1";
 $res = $pdo->query($sql)->fetch();
 $number = $res['number'];
 if($number>0)
 {
 $sql ="insert into `order` VALUES (null,$number)";

 $order_id = $pdo->query($sql);
 if($order_id)
 {

  $sql="update storage set `number`=`number`-1 WHERE id=1";
  $pdo->query($sql);
 }
 }
 //解锁
 $lockObj->del('storage');

}
else
{
 //加锁不成功执行其他操作。
}
 
再次进行ab测试，查看测试结果
 
mysql> select * from `order`;
+----+--------+
| id | number |
+----+--------+
| 1 | 10 |
| 2 | 9 |
| 3 | 8 |
| 4 | 7 |
| 5 | 6 |
| 6 | 5 |
| 7 | 4 |
| 8 | 3 |
| 9 | 2 |
| 10 | 1 |
+----+--------+
10 rows in set (0.00 sec)
 
发现订单表没有操作同一个库存数据的情况。所以利用redis锁是可以有效的处理高并发的。
 
这里在加锁的时候其实是可以不需要判断过期时间的，这里我们为了避免造成死锁，所以加一个过期时间的判断。当过期的时候主动删除该锁。

背景：在集群多台服务器的系统会产生同一秒钟请求多次的情况；
 
解决方案：为了解决这种高并发的情况可以使用Redis进行处理，常见的方式先进行Redis.GetValue(key)，如果值不存在的情况下，进行Redis.SetValue(key,10);这种情况如果是同一秒钟进行请求的时候是无法进行拦截的，具体的可以使用Jmeter进行性能应用进行请求处理；
 
改善的方法：使用Redis.SetNX进行改写
 
在 Redis 里，所谓 SETNX，是「SET if Not eXists」的缩写，也就是只有不存在的时候才设置，可以利用它来实现锁的效果。
 
通过测试进行的效果可以看到这个是可以进行同一秒钟多个请求的拦截处理；
 
2.如果不是同一秒甚至与是10秒之后的二次回写的问题这个可以使用数据库的原子性操作进行业务的更新、插入操作；
 
如果更新的结果是0，说明该操作已经处理，就不能进行二次的处理，该情况适用于一个方法的执行时间较长，并且在请求的时候数据状态是1，当真正进行处理业务的时候该数据的状态0已经无效了，这个时候就不能进行功能的处理，否则会把0值更新为1；导致的业务异常；