java-07 多线程-并发编程(分布式锁、Redis锁)

于 2024-10-11 10:41:26 发布
阅读量507 收藏 7
点赞数 10
分类专栏： java基础 文章标签： java 分布式 redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyh106115/article/details/142842880
版权

分布式锁是用于控制分布式系统中的多个节点对共享资源的访问。由于分布式系统中的节点可能位于不同的机器甚至不同的地理位置，因此分布式锁的实现比线程锁和进程锁要复杂得多。分布式锁需要在网络中的多个节点之间进行协调，以保证锁的唯一性和一致性。

分布式锁就像是一个网络版的门卫，确保在多台计算机上运行的程序不会同时操作同一个数据。想象一下，每台计算机都要先拿到这个门卫的钥匙，才能操作数据。这样，就能防止数据混乱，确保每次只有一个程序在使用数据。

如果你觉得我分享的内容或者我的努力对你有帮助，或者你只是想表达对我的支持和鼓励，请考虑给我点赞、评论、收藏。您的鼓励是我前进的动力，让我感到非常感激。

文章目录

1 分布式锁简介

1.1 什么是分布式锁

分布式锁是一种在分布式系统环境下，通过多个节点对共享资源进行访问控制的一种同步机制。它的主要目的是防止多个节点同时操作同一份数据，从而避免数据的不一致性。

  • 线程锁：
    也被称为互斥锁（Mutex），主要用于控制同一进程中的多个线程对共享资源的访问。
  • 进程锁：
    进程锁是用于控制同一台机器上的多个进程对共享资源的访问。进程锁可以是系统级的，如文件锁，也可以是用户级的，如信号量（Semaphore）。
  • 分布式锁：
    分布式锁是用于控制分布式系统中的多个节点对共享资源的访问。由于分布式系统中的节点可能位于不同的机器甚至不同的地理位置，因此分布式锁的实现比线程锁和进程锁要复杂得多。分布式锁需要在网络中的多个节点之间进行协调，以保证锁的唯一性和一致性。

1.2 分布式锁的特性

分布式锁主要有以下几个特性：

  • 互斥性： 在任何时刻，只有一个节点可以持有锁。
  • 不会发生死锁： 如果一个节点崩溃，锁可以被其他节点获取。
  • 公平性： 如果多个节点同时申请锁，系统应该保证每个节点都有获取锁的机会。
  • 可重入性： 同一个节点可以多次获取同一个锁，而不会被阻塞。
  • 高可用： 锁服务应该是高可用的，不能因为锁服务的故障而影响整个系统的运行。

2 分布式锁的基本原理

2.1 分布式锁的基本步骤

分布式锁的基本原理可以分为以下几个步骤：

  1. 请求锁： 当一个实例需要访问共享资源时，它会向分布式锁系统发送一个请求，试图获取一个锁。
  2. 锁定资源： 分布式锁系统会检查是否有其他实例已经持有这个锁。如果没有，那么这个实例就会获得锁，并且有权访问共享资源。如果有，那么这个实例就必须等待，直到锁被释放。
  3. 访问资源： 一旦实例获取了锁，它就可以安全地访问共享资源，而不用担心其他实例会同时访问这个资源。
  4. 释放锁： 当实例完成对共享资源的访问后，它需要通知分布式锁系统释放锁。这样，其他正在等待的实例就可以获取锁，访问共享资源。
    在这里插入图片描述

2.2 分布式锁实现的关键点

在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。

当一个节点申请锁时，中心节点会检查当前是否有其他节点持有锁，如果没有，则将锁分配给申请的节点；如果有，则拒绝申请。当持有锁的节点完成操作后，会向中心节点归还锁，此时其他的节点可以再次申请锁。
在这里插入图片描述

3 基于Redis的分布式锁

3.1 基本介绍

Redis是一个开源的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息代理。

Redis 提供了多种命令和能力来支持实现分布式锁

  • SETNX 命令： SETNX（Set if Not Exists）命令用于在 key 不存在时设置值。这是实现分布式锁的关键命令，因为它能确保在同一时间只有一个客户端能够获得锁。
  • EXPIRE 命令： EXPIRE 命令用于为 key 设置过期时间。这对于避免死锁非常重要，因为即使某个客户端崩溃，锁也会在一定时间后自动释放。
  • DEL 命令： DEL 命令用于删除 key。在释放锁时，需要使用此命令删除对应的 key。
  • Lua 脚本： Redis 支持使用 Lua 脚本来执行一系列原子操作。这对于实现安全的分布式锁非常有用，因为它可以确保在释放锁时检查锁的持有者。
  • RedLock 算法： Redis 官方推荐了一种名为 RedLock 的分布式锁算法。RedLock 是一种基于多个 Redis 实例的分布式锁算法，旨在提供更高的安全性和容错能力。
    一般，在实现Redis分布式锁时，不分开使用SETNX和EXPIRE命令，而是使用SETNX的拓展命令 SET NX EX

3.2 Redis实现分布式锁的基本实现

3.2.1 请求锁

setIfAbsent( key, value)

  1. 如果键不存在则新增,存在则不改变已经有的值。
  2. 存在返回 false，不存在返回 true。
boolean lock = redisTemplate.opsForValue().setIfAbsent("testKey","123");
   一开始是不存在key “testKey” 的，所以lock 为 true；但是后面创建并添加了值“123”。
redisTemplate.opsForValue().get("testKey")； 
   是有值的，为“123”。

lock = redisTemplate.opsForValue().setIfAbsent("testKey","321");
    已存在key “testKey”，所以无法赋值，lock 为 false；
redisTemplate.opsForValue().get("testKey")；
    值没变，还是“123”。

    public boolean tryLock(String lockKey, String lockValue, Long lockOutTime) {
        return lockKey != null && lockValue != null && lockOutTime != null ? this.redisTemplate.opsForValue()
            .setIfAbsent(lockKey, lockValue, lockOutTime, TimeUnit.SECONDS) : false;
    }

3.2.2 锁续期

为了防止锁过早地因为过期而被释放，可以在锁快到期时进行续期操作。这可以通过定期检查锁的剩余时间，并在必要时使用 EXPIRE 命令来更新过期时间来实现。

RedisTemplate里的方法:

  • 获取过期时间
	@Autowired
	private RedisTemplate<String, Object> redisTemplate;
	
	public Long getExpire(String key) {
	    return redisTemplate.getExpire(key, TimeUnit.SECONDS);
	}
  • 设置过期时间
	@Override
	public Boolean expire(K key, final long timeout, final TimeUnit unit) {...

3.2.3 释放锁

当客户端完成需要加锁保护的操作后，应该释放锁。为了确保只有锁的持有者才能释放锁，可以使用 Lua 脚本来执行释放操作。

    public void releaseLock(String lockKey, String lockValue) {
        List<String> keys = new ArrayList();
        keys.add(lockKey);
        List<String> args = new ArrayList();
        args.add(lockValue);
        Long result = (Long)this.redisTemplate.execute(new LongRedisCallback(keys, args));
    }

3.2.4 使用案例

工具类：
RedisUtils

    /**
     * Gets distribute lock.
     *
     * @param lockKey the lock key
     * @param lockValue the lock value
     * @param retryTime the retry time
     * @param timeOut the time out  锁超时时间，超过这个时间后自动释放
     */
    public void getDistributeLock(String lockKey, String lockValue, int retryTime, long timeOut) {
        try {
            int count = 0;
            while (!distributeLock.tryLock(lockKey, lockValue, timeOut)) {
                redisTemplate.expire(lockKey, timeOut, TimeUnit.SECONDS);
                count++;
                if (count > retryTime) {
                    log.warn("Get lock fail.");
                    throw new CommonServiceException(AIModelError.REDIS_GET_LOCK_EXCEPTION, " lockKey: " + lockKey);
                }
                Thread.sleep(300);
            }
        } catch (InterruptedException exp) {
            log.error("Get lock error.");
            throw new CommonServiceException(AIModelError.REDIS_GET_LOCK_EXCEPTION, " lockKey: " + lockKey, exp);
        }
    }

    /**
     * Release lock.
     *
     * @param lockKey the lock key
     * @param lockValue the lock value
     */
    public void releaseLock(String lockKey, String lockValue) {
        distributeLock.releaseLock(lockKey, lockValue);
    }
    
    /**
     * 模糊删除指定key
     *
     * @param key <description>
     * @return Boolean <description>
     */
    public Boolean dimDelete(String key) {
        // redis开关判断
        if (!isOpen) {
            return false;
        }
        try {
            Set<String> keys = redisUtil.scan(key + "*");
            if (CollectionUtils.isEmpty(keys)) {
                return false;
            }
            return redisTemplate.delete(keys) > 0;
        } catch (Exception e) {
            log.error("key:{}", key);
            log.error("RedisUtils.dimDelete error.", e);
        }
        return false;
    }

RedisDistributeLock

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import redis.clients.jedis.Jedis;

public class RedisDistributeLock {
    private static final Long SLEEPTIME_SECONDS = 2L;
    private static final Long FREQUENCY = 3L;
    private static final String UNLOCK_LUA;
    private StringRedisTemplate redisTemplate;

    public RedisDistributeLock() {
    }

    private String getValue(String key) {
        return key == null ? null : (String)this.redisTemplate.opsForValue().get(key);
    }

    private void expire(String key, long timeout, TimeUnit timeUnit) {
        if (key != null) {
            this.redisTemplate.expire(key, timeout, timeUnit);
        }
    }

    public boolean tryLock(String lockKey, String lockValue, Long lockOutTime) {
        return lockKey != null && lockValue != null && lockOutTime != null ? this.redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, lockOutTime, TimeUnit.SECONDS) : false;
    }

    public void releaseLock(String lockKey, String lockValue) {
        List<String> keys = new ArrayList();
        keys.add(lockKey);
        List<String> args = new ArrayList();
        args.add(lockValue);
        Long result = (Long)this.redisTemplate.execute(new LongRedisCallback(keys, args));
    }

    public void doDaemon(String lockKey, String lockValue, Long lockOutTimeSeconds) throws InterruptedException {
        Callable<Integer> callable = this.setDaemon(lockKey, lockValue, lockOutTimeSeconds);
        FutureTask<Integer> futureTask = new FutureTask(callable);
        (new Thread(futureTask)).start();
        TimeUnit.SECONDS.sleep(SLEEPTIME_SECONDS);
    }

    private Callable<Integer> setDaemon(String lockKey, String lockValue, Long lockOutTimeSeconds) {
        return () -> {
            long waitTime = lockOutTimeSeconds / FREQUENCY;

            while(true) {
                TimeUnit.SECONDS.sleep(waitTime);
                String value = this.getValue(lockKey);
                if (value == null || !value.equals(lockValue)) {
                    return 0;
                }

                this.expire(lockKey, lockOutTimeSeconds, TimeUnit.SECONDS);
            }
        };
    }

    public void setRedisTemplate(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    static {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("return 0 ");
        sb.append("end");
        UNLOCK_LUA = sb.toString();
    }

    private static class LongRedisCallback implements RedisCallback<Long> {
        private final List<String> keys;
        private final List<String> args;

        public LongRedisCallback(List<String> keys, List<String> args) {
            this.keys = keys;
            this.args = args;
        }

        public Long doInRedis(RedisConnection connection) {
            Object nativeConnection = connection.getNativeConnection();
            return (Long)((Jedis)nativeConnection).eval(RedisDistributeLock.UNLOCK_LUA, this.keys, this.args);
        }
    }
}

使用
正常使用

    @GetMapping(value = "/redisTest")
    public String redisTest() {
        // 首先，获取锁，不能放在下面的try代码块里，方式获取锁失败后，把别人正在使用的锁释放
        redisUtils.getDistributeLock(Constants.RedisConstants.UPDATE_TASK_LOCK_KEY_PREFIX,
            Constants.RedisConstants.UPDATE_TASK_LOCK_VALUE, Constants.RedisConstants.UPDATE_TASK_LOCK_RETRY_TIME, 60l);
        try {
            // TODO 业务代码【在处理业务时，可以查询过期时间，也可以延续过期时间】
        } finally {
        	// 释放锁
            redisUtils.releaseLock(Constants.RedisConstants.UPDATE_TASK_LOCK_KEY_PREFIX,
                Constants.RedisConstants.UPDATE_TASK_LOCK_VALUE);
        }
        return "OK";
    }

项目启动后清理锁

    private void clearRedisCache() {
        try {
            redisUtils.dimDelete(Constants.RedisConstants.UPDATE_TASK_LOCK_KEY_PREFIX);
        } catch (Exception exp) {
            log.error("clean redis cache error!");
            ExceptionUtils.printExceptionInfo(exp);
        }
    }

3.3 Redis分布式锁的使用场景

Redis分布式锁可以用于所有需要在分布式环境中同步访问共享资源的场景。例如，电商秒杀活动中，为了防止超卖，可以使用Redis分布式锁来保证同一时刻只有一个请求可以操作库存。又如，在分布式计算中，为了防止重复计算，可以使用Redis分布式锁来保证同一时刻只有一个节点可以进行计算。

3.4 Redis分布式锁的优点和缺点

优点：

  • 性能高：由于Redis是基于内存的，因此Redis分布式锁的性能非常高。
  • 实现简单：Redis提供的命令可以很容易地实现分布式锁。

缺点：

  • 不可重入：Redis分布式锁默认是不可重入的，如果需要可重入，需要额外的逻辑来实现。
  • 非阻塞：Redis分布式锁是非阻塞的，如果获取锁失败，需要自己进行重试。
  • 安全性：如果Redis服务器出现故障，可能会导致锁无法正常工作。

4 其他分布式锁的实现方式

4.1 基于数据库的分布式锁

  • 数据库分布式锁是通过在数据库中创建一个锁表，表中包含锁的名称和锁的状态等信息。
  • 当一个节点需要获取锁时，它会在这个表中插入一条记录，如果插入成功，那么这个节点就获取到了锁。当节点使用完锁后，会删除这条记录，从而释放锁。
  • 这种方式的优点是实现简单，缺点是性能较低，且如果数据库出现故障，可能会影响到锁的功能。

4.2 基于Zookeeper的分布式锁

  • Zookeeper是一个开源的分布式协调服务，它提供了一种高效且可靠的分布式锁实现方式。
  • 在Zookeeper中，可以创建一个临时节点作为锁，当一个节点需要获取锁时，它会尝试创建这个临时节点，如果创建成功，那么这个节点就获取到了锁。
  • 当节点使用完锁后，会删除这个临时节点，从而释放锁。如果节点崩溃，Zookeeper会自动删除这个临时节点，从而避免了死锁的问题。

4.3 基于Etcd的分布式锁

  • Etcd是一个开源的分布式键值存储系统，它也提供了一种分布式锁的实现方式。
  • Etcd的分布式锁是通过创建一个带有TTL（Time To Live）的键值对来实现的，当一个节点需要获取锁时，它会尝试创建这个键值对，如果创建成功，那么这个节点就获取到了锁。
  • 当节点使用完锁后，会删除这个键值对，从而释放锁。如果节点崩溃，Etcd会自动删除这个键值对，从而避免了死锁的问题。

5 各种实现方式的比较

在这里插入图片描述在选择分布式锁的实现方式时，需要根据具体的应用场景和需求来决定。

6 分布式锁的常见问题和解决方案

6.1 死锁问题

问题：
当一个客户端获取了锁，但由于某些原因（如程序崩溃、异常等）无法释放锁时，会导致其他客户端永远无法获取锁。
解决方案：
设置锁的过期时间。当锁的持有者未能在过期时间内执行完毕并释放锁时，锁将自动过期，从而允许其他客户端获取锁。

6.2 锁续命问题

问题：
如果一个操作需要的时间可能超过锁的过期时间，那么在操作执行过程中锁过期会导致其他客户端获取到锁，从而产生并发问题。
解决方案：
使用锁续命机制。在锁持有者执行操作期间，可以定期检查锁是否即将过期，并在适当的时候对锁进行续命，即重新设置锁的过期时间。

6.3 锁释放问题

问题：
为确保数据的一致性，只有锁的持有者才能释放锁。但在实际应用中，可能会出现误解锁的情况。
解决方案：
在设置锁时，为锁关联一个唯一的值（如UUID）。在释放锁时，先检查锁的值是否与当前客户端的值匹配，如果匹配则释放锁，否则不做任何操作。注意，锁持有人的判断和锁的释放应该在一个原子操作内完成。

6.4 锁的公平性问题

问题：
在高并发环境中，如果多个节点同时请求获取锁，可能会出现“饥饿”现象，即某些节点长时间无法获取到锁。
解决方案：
引入队列，将请求锁的节点按照顺序排队。例如，在Zookeeper中，可以使用顺序节点来实现公平锁。

6.5 锁的可重入性问题

问题：
在某些场景中，一个节点可能需要多次获取同一个锁，如果锁不支持重入，可能会导致死锁。
解决方案：
为锁添加一个拥有者的概念，只有锁的拥有者才能再次获取到锁。例如，在Redis中，可以将锁的值设置为节点的唯一标识，获取锁时检查锁的值是否为自己的标识。

6.6 锁的安全性问题

问题：
如果分布式锁的存储系统（如Redis、Zookeeper等）出现故障，可能会导致锁无法正常工作。
解决方案：
使用高可用的存储系统，如使用Redis集群或Zookeeper集群。另外，可以使用心跳机制来检测存储系统的状态，如果检测到故障，可以及时进行切换。

wyh106115
关注
专栏目录
C#实操控制并发之Lock和Redis分布式锁
01-21
并发控制是指在多线程环境下确保数据的一致性和完整性，防止多个线程同时访问同一资源导致数据不一致。在C#中，Lock机制是一种常见的并发控制手段，它提供了独占访问，确保在同一时刻只有一个线程可以执行特定代码块...
使用redis分布式锁解决并发线程资源共享问题
12-16
众所周知, 在多线程中，因为共享全局变量,会导致资源修改结果不一致，所以需要加锁来解决这个问题，保证同一时间只有一个线程对资源进行操作 但是在分布式架构中，我们的服务可能会有n个实例，但线程锁只对同一个...
Redis分布式锁--java实现
Artisan_w
01-13 2453
在单体redis中通过SETNX + EXPIRE方式可以为多个JVM加一个分布式锁，但是由于操作的非原子性会导致并发问题，因此出现了几种原子性解决方法，包括SETNX+时间value、lua脚本和SET扩展命令的方式解决，但是，依然会出现事务还没完成时间就失效，产生了新一轮并发，因此，通过添加一个看门狗线程定期检查能够解决这个问题，对于一个Java开发来说有一个Redisson框架实际上封装了lua脚本来实现。 哨兵和主从模式下的分布式redis，介绍了Redlock的原理与其缺陷。
java多线程：redis分布式锁在不同业务场景下的应用
maligebilaowang的博客
04-01 1201
首先，一个抽奖活动一个用户可以抽多次，-1问题出现的原因是因为这个用户疯狂的点击抽奖，前端没有限制，因此大量的请求发送到后台，当用户把抽奖次数耗光了，只剩下1次抽奖机会，两个请求同时过来，验证的时候发现剩余抽奖次数都是1，因此都可以进行抽奖，所以抽了两回，记录插入两回，剩余次数变成了1-2=-1。redis锁在这里的主要应用就是，针对缓存失效的情况，所有的评价配置获取请求都会走查询数据库，大量配置查询请求有可能打挂数据库，因此需要对评价配置请求进行并发控制；
多线程并发解决方案-分布式锁
weixin_38376791的博客
09-03 837
分布式锁 基于Redis 1.可以使用Redisson实现分布式锁； @SpringBootTest class DemoApplicationTests { @Resource private Redisson redisson; @Resource private RedisTemplate redisTemplate; @Test public void deductStock() { //获取锁 String
Java Redis并发读写锁，使用Redisson实现分布式锁
牛肉胡辣汤
07-20 880
Redisson是一个基于Redis的开源Java库，提供了一组强大的分布式对象和服务，包括分布式锁、分布式集合、分布式对象以及许多其他功能。它通过简单易用的API，为Java开发人员提供了方便的方式来构建分布式应用程序。
Redis-分布式锁
m0_71386740的博客
07-28 1579
基于Redis的分布式锁实现思路：利用set nx ex获取锁，并设置过期时间，保存线程标示释放锁时先判断线程标示是否与自己一致，一致则删除锁特性：利用set nx满足互斥性利用set ex保证故障时锁依然能释放，避免死锁，提高安全性利用Redis集群保证高可用和高并发特性利用lua脚本确保一致性分布式锁-redission重入问题。
Java 使用redis实现分布式锁
weixin_45410882的博客
09-30 994
Java SpringCloud实现分布式锁 (jedis、jedis+lua、redisson)
Java 实现基于Redis的分布式锁
Yoiami的博客
07-24 1300
本文提供了 Java + Lua 实现的基于 Redis 的分布式锁，这里的实现保证了微服务对资源的独占性并实现了锁的可入重性。但是，对于某些情况下，该实现似乎并没有正常工作，而且暂时没有正确定位到问题。
Redis(九) - Redis之分布式锁
及时当勉励，岁月不待人
07-27 9328
Redis(九) - Redis之分布式锁
Java三种方式实现redis分布式锁
热门推荐
了迹奇有没
04-28 2万+
一、引入原因 在分布式服务中，常常有如定时任务、库存更新这样的场景。 在定时任务中，如果不使用quartz这样的分布式定时工具，只是简单的使用定时器来进行定时任务，在服务分布式部署中，就有可能存在定时任务并发执行，造成一些问题。 在库存更新这样的场景中，我们服务对数据库同一条记录进行更新，并记录。对记录更新可以使用分布式锁，但对操作进行记录时，可能造成读未提交，造成记录错乱的情况。 在以上的场景中，我们引入了分布式事务锁。 二、分布式锁实现过程中的问题 问题一：异常导致锁没有释放 这个问题形成的原因就是程序
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
总结来说，通过Redis实现分布式锁，可以有效解决多节点间的资源竞争问题。使用自旋式加锁策略可以确保锁的获取，而Lua脚本则为解锁提供了原子性保证，从而避免了并发环境下的数据一致性问题。在实际应用中，还可以...
C#.net Redis分布式锁源码实现
02-27
在IT行业中，尤其是在大型...总结起来，C#.NET结合Redis实现分布式锁涉及到连接管理、命令使用、原子操作、锁的生命周期管理等多个方面。理解这些核心概念，并在实践中灵活应用，可以帮助构建高效、可靠的分布式系统。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1287
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 381
JDK1.0主要特性。
Puppeteer自动化：使用JavaScript定制PDF下载
ip16yun的博客
10-08 791
Puppeteer 是一个强大的Node.js库，提供了对无头Chrome或Chromium的控制，可以用于生成网页快照、抓取数据、自动化测试等任务。其中，生成PDF文件是一个常见的需求，本文将通过使用Puppeteer展示如何自动化生成定制的PDF，并使用代理IP、设置user-agent、cookie等技术来增强自动化过程的灵活性与稳定性。为了更好地理解如何定制Puppeteer生成的PDF文件，我们提供一个生成A4纸张格式的网页PDF的实例。用户可以根据需求自定义输出的PDF格式或内容。
Netty 相比原生IO模型的优势
最新发布
lssffy的博客
10-09 610
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1139
2024最新Java面试题，针对一些小厂，中厂
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值