public class RedisLock {

    private static Long stock = 1L;

    public static void placeOrder() throws InterruptedException {
        if (stock > 0){
            Thread.sleep(100);
            stock--;
            System.out.println(Thread.currentThread().getName() + "秒杀成功");
        }else {
            System.out.println(Thread.currentThread().getName() + "秒杀失败！存不足");
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                try {
                    placeOrder();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

public class RedisLock {

    private static Long stock = 1L;

    public static void placeOrder() throws InterruptedException {
        //加入同步锁
        synchronized (stock){
            if (stock > 0){
                Thread.sleep(100);
                stock--;
                System.out.println(Thread.currentThread().getName() + "秒杀成功");
            }else {
                System.out.println(Thread.currentThread().getName() + "秒杀失败！存不足");
            }
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                try {
                    placeOrder();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

public class RedisDemo {
    public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool("192.168.200.128",6379);//创建连接池
        Jedis jedis = jedisPool.getResource();//从连接池获取
        String ping = jedis.ping();//测试链接
        System.out.println(ping);//如果成功连接上了Redis服务，此处将会输出PONG
        jedis.close();//释放资源，进行归还线程
    }
}

public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool();
        Jedis jedis = jedisPool.getResource();
        jedis.set("token", UUID.randomUUID().toString());
        System.out.println("token" + jedis.get("token"));
        jedis.close();
    }

public static void main(String[] args) {
     JedisPool jedisPool = new JedisPool();
     try (Jedis jedis = jedisPool.getResource()){
         //Redis相关业务...
         jedis.set("name","Johnny");
     }
 }

//定义一个接口
 public interface CallJedis {
     void call(Jedis jedis);
 }
 
 //自己封装一个可以安全使用的连接池
 public class MyRedisPool {
     private JedisPool jedisPool;
     //实例化连接池
     public MyRedisPool() {
         this.jedisPool = new JedisPool();
     }
     //获取Redis连接资源，并确保在使用后归还
     public void execute(CallJedis caller){
         try(Jedis jedis = jedisPool.getResource()){
             caller.call(jedis);
         }
     }
 }
 
 //这样子我们就可以安全的使用Redis啦
 public static void main(String[] args) {
     //实例化连接池
     MyRedisPool myRedisPool = new MyRedisPool();
     //获取Redis连接资源，并确保在使用后归还
     myRedisPool.execute(new CallJedis() {
         @Override
         public void call(Jedis jedis) {
             //执行Redis相关业务...
             jedis.set("name","Johnny");
             System.out.println(jedis.get("name"));
         }
     });
 }
这样子，我们通过自己封装的Jedis连接池来获取并归还连接，避免了自己获取连接然后忘记归还的情况。但是每次使用都需要提供一个回调类来执行Redis代码，略显麻烦。这同样可以使用Java8提供的新特性Lambda表达式来简化代码，如下

 public static void main(String[] args) {
     MyRedisPool myRedisPool = new MyRedisPool();
     myRedisPool.execute(jedis -> {
         //Redis相关业务...
         jedis.set("name","Johnny");
         Systrem.out.println(jedis.get("name"));
     });
 }

public static void main(String[] args) {
    //连接本地的 Redis 服务
    Jedis jedis = new Jedis("127.0.0.1", 6379);
    String response = jedis.ping();
    System.out.println(response); // PONG

    //删除当前选择数据库中的所有key
    System.out.println("删除当前选择数据库中的所有key：" + jedis.flushDB());

    //设置 redis 字符串数据
    //新增<'name','yixin'>的键值对
    jedis.set("name","huhu");
    // 获取存储的数据并输出
    System.out.println("redis 存储的字符串为: "+ jedis.get("name"));

    //判断某个键是否存在
    System.out.println("redis 存储的字符串是否存在：" + jedis.exists("name"));

    //系统中所有的键
    Set<String> keys = jedis.keys("*");
    System.out.println(keys);

    //按索引查询
    System.out.println("按索引查询:"+ jedis.select(0));

    //查看键name所存储的值的类型
    System.out.println(jedis.type("name"));

    // 随机返回key空间的一个
    System.out.println(jedis.randomKey());

    //重命名key
    System.out.println(jedis.rename("name","username"));
    System.out.println("取出改后的name:" + jedis.get("username"));

    //删除键username
    System.out.println("删除username:" + jedis.del("username"));

    //删除当前选择数据库中的所有key
    System.out.println("删除当前选择数据库中的所有key：" + jedis.flushDB());

    //查看当前库中所有的key的数目
    System.out.println("返回当前数据库中key的数目："+jedis.dbSize());

    //删除数据库中的所有key
    //System.out.println("删除数据库中的所有key:" + jedis.flushAll());
}

public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        String response = jedis.ping();
        System.out.println(response); // PONG
 
      System.out.println("删除当前选择数据库中的所有key："+jedis.flushDB());
 
        //List实例
        //存储数据到列表中
        jedis.lpush("list", "num1");
        jedis.lpush("list", "num2");
        jedis.lpush("list", "num3");
        
        // 获取存储的数据并输出
        List<String> list = jedis.lrange("list", 0 ,-1);
        for(int i=0; i<list.size(); i++) {
            System.out.println("列表项为: "+list.get(i));
        }
    }

public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        String response = jedis.ping();
        System.out.println(response); // PONG
 
        //事务测试
        jedis.flushDB();
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello","world");
        jsonObject.put("name","yixin");
 
        //开启事务
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();
        // jedis.watch(result)
        try {
            multi.set("user1", result);
            multi.set("user2", result);
            int i = 1 / 0; // 代码抛出异常事务，执行失败！
            multi.exec(); // 执行事务！
 
        }catch (Exception e){
            multi.discard();// 放弃事务
            e.printStackTrace();
        }finally {
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            jedis.close();
        }
    }

@Autowired
   private RedisTemplate redisTemplate;

   @Test
   void contextLoads() {
       redisTemplate.opsForValue().set("name","huhu");
       System.out.println(redisTemplate.opsForValue().get("name"));
   }

package com.itheima.pojo;

import java.io.Serializable;

public class User implements Serializable {

    private String name;
    private int age;

    public  User(){

    }
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}

@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        //为了自己开发方便，一般直接使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);

        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;

    }

}

@Test
    public void contextLoads() {
        User user=new User("huhu",18);
        redisTemplate.opsForValue().set("user",user);
        System.out.println(redisTemplate.opsForValue().get("user"));

    }

在Java中可以通过使用Redisson库来增加Redis重试机制。Redisson是一个基于Redis的Java驻留内存数据网格（In-Memory Data Grid）和分布式锁服务。它提供了一种简单的方式来处理Redis命令的重试。

下面是一个使用Redisson实现Redis重试机制的示例代码：

import org.redisson.Redisson;
import org.redisson.api.RFuture;
import org.redisson.api.RMap;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class RedisRetryExample {
    public static void main(String[] args) {
        // 创建Redisson客户端
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        RedissonClient redisson = Redisson.create(config);

        // 获取Redis Map对象
        RMap<String, String> map = redisson.getMap("myMap");

        // 设置重试次数
        int maxRetries = 3;

        // 执行Redis命令
        boolean success = false;
        for (int i = 0; i < maxRetries; i++) {
            try {
                RFuture<Boolean> future = map.fastPutAsync("key", "value");
                success = future.await();
                if (success) {
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 关闭Redisson客户端
        redisson.shutdown();

        // 处理执行结果
        if (success) {
            System.out.println("Redis命令已成功执行");
        } else {
            System.out.println("重试后 Redis 命令失败");
        }
    }
}


在上述示例中，我们使用Redisson创建了一个RedissonClient对象，并通过它来执行Redis命令。在执行命令时，我们使用了`fastPutAsync`方法来异步执行Redis的`SET`命令，并使用`await`方法等待命令执行结果。

如果命令执行成功，则跳出循环；如果命令执行失败，则继续进行重试。在重试过程中，可以根据实际需求进行异常处理或者记录日志。最后，根据重试结果来处理执行成功或失败的情况。

需要注意的是，重试机制并不能保证100%的命令执行成功，但可以提高命令执行成功的概率。在实际应用中，可以根据具体情况来设置重试次数和重试间隔，以达到最佳的重试效果。

在Java中，Lambda表达式内是可以访问外部的final或effectively final变量的，但是无法修改它们的值。如果需要在闭包外部获取Redis中某个List的长度，可以使用一个包装类或者数组来存储这个长度值，并将它声明为final或effectively final变量。

例如，可以创建一个长度为1的数组来存储List的长度值：

final int[] length = new int[1];

// 在闭包内获取Redis中List的长度，并将结果存储到数组中
redisTemplate.execute((RedisCallback<Object>) connection -> {
    length[0] = connection.lLen("listKey");
    return null;
});

// 在闭包外部可以访问length[0]获取List的长度
int listLength = length[0];

另外，如果使用的是Java 8及以上版本，也可以使用AtomicInteger类来存储长度值，它提供了原子操作保证线程安全：

AtomicInteger length = new AtomicInteger();

// 在闭包内获取Redis中List的长度，并将结果存储到AtomicInteger中
redisTemplate.execute((RedisCallback<Object>) connection -> {
    length.set(connection.lLen("listKey").intValue());
    return null;
});

// 在闭包外部可以通过length.get()获取List的长度
int listLength = length.get();

通过以上方式，可以在闭包外部获取到Redis中List的长度值。