浅谈长轮询及其封装实现

最新推荐文章于 2025-03-17 21:26:31 发布
最新推荐文章于 2025-03-17 21:26:31 发布
阅读量2.2k 收藏 33
点赞数 45
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_87705318/article/details/142821887
版权

1. 简介

长轮询是与服务器保持即时通信的最简单方式，它不依赖双向通信协议，例如 WebSocket，只需要支持http协议即可 ，也不依赖于浏览器版本等外部条件的兼容性，它很容易实现，也无需引入其他依赖，在很多场景下可以作为即时通信的最简单实现方案和兜底兼容方案。

2. 长轮询（Long polling）和常规轮询的区别

2.1 常规轮询

从服务器获取新信息的最简单的方式是定期轮询。也就是说，定期向服务器发出请求：“你好，我在这儿，你有关于我的任何消息吗？”例如，每 10 秒一次。
作为响应，服务器立即向客户端发送自上一次轮询到目前为止的消息包，即便当前可能并没有新的消息。
这可行，但是也有缺点：

  1. 消息传递的延迟最多为 10 秒（两个请求之间）。
  2. 即使没有消息，客户端为了维持消息一定的即时性，服务器也会每隔 10 秒被请求一次，就性能而言，这是一个很大的负担。

因此，如果我们讨论的是一个很小负载的服务，那么这种方式可能可行，但总的来说，不足之处也很明显。

示意图： 

2.2 长轮询

相比于常规轮询，长轮询的无效请求可以大大减少，另外也具有类似实时推送的特性，消息具有实时性。

其流程为：

  1. 请求发送到服务器。
  2. 服务器在有新数据之前不会响应请求。
  3. 当新数据出现、或超过预设等待时间时，服务器将对其请求作出响应。
  4. 浏览器立即发出一个新的请求。

此时轮询的主动权虽然理论上依然在浏览器，但由于浏览器下一次请求的时机实际上取决于服务器上一次响应的动作，所以服务器端可以控制客户端轮询的频率，具体的方式就是服务器端设置长轮询超时响应时间。

这个时间如果设置为20秒，含义是如果浏览器发起请求20秒内某一个时间点有了新消息，则立即响应浏览器，如果20秒内没有新消息，则返回一个超时状态的响应给浏览器，浏览器开启下一次长轮询。

示意图： 

3. Servlet的同步与异步

长轮询挂起请求，等待新数据更新后再响应的处理方式虽然能减少浏览器的请求次数，并带来即时性，但是如果使用同步处理请求的方式，挂起请求则代表了线程的阻塞，有多少长轮询请求未响应就代表要阻塞多少个Servlet线程，这显然是不合理的，所以长轮询必须使用异步处理的方式，而Servlet 3.0开始已经支持了异步处理。

3.1 同步处理请求：


从上图可以看出：请求到达后，从主线程池获取一个线程，处理业务，响应请求，然后将线程还回线程池，整个过程都是由同一个主线程在执行。
这里存在一个问题，通常 Servlet容器的主线程数量是有限的，若执行业务的比较耗时，大量请求过来之后，主线程被耗光，新来的请求就会处于等待状态，而长轮询的长时间等待动作，则会剧烈放大这个问题，主线程很容易就会处于全部阻塞的状态，无法处理新的请求。
而 servlet3.0 中对这个过程做了改进，主线程可以将请求转交给其他线程去处理，比如开发者可以自定义一个线程，然后在自定义的线程中处理请求。

3.2 异步处理请求：


如上图，在主线程中开启异步处理，主线程将请求交给其他线程去处理，主线程就结束了，被放回了主线程池，由其他线程继续处理请求，可以避免主线程池线程耗尽，起到容器线池程和工作线程池隔离的效果。

4. 异步处理的长轮询

仅仅是线程池隔离还是不够的，因为工作线程池依然会因为等待阻塞而面临耗尽的问题，解决方案是使用单独的守护线程或者监听器监听响应事件队列。
例如微信服务器回调消息就可以看做是一个响应事件，这个事件被包装成对象放入队列中，守护线程通过阻塞的方式获取到事件对象后调用自定义线程池中的工作线程，工作线程从请求池中取出并删除异步请求域对象AsyncContext，然后进行数据准备和任务处理，完成对前端的响应。
需要注意的是，每一个长轮询请求都会对应一个超时任务，这个超时任务会提交给ScheduledThreadPoolExecutor定时任务线程池，当超时时间到了后，会去请求池查找对应的请求是否还存在（如已响应则会被删除），如果还存在则会响应前端长轮询超时。
长轮询超时不是通常意义上的请求超时，而是在指定时间范围内没有新的数据需要返回，这个状态值需要和前端协调好，属于是正常的响应状态。
如下图所示：


当然，实际使用中会出现，新数据出现了但是请求对象已经超时响应过，但新的请求并没有发送到服务端的情形，这种情况可以理解为“用户下线了”，此时需要标记用户有未送达的信息，并对响应事件做好持久化工作。
当用户再次上线发起长轮询时，判断用户是否有未送达的消息，如有则将持久化信息从右侧塞入响应事件队列中，优先响应给用户旧信息。

5. 案例

5.1 案例描述

用户在网页使用微信扫码登陆，并且需要同时关注公众号，需要用到公众号接收事件推送，用户使用手机微信app扫码后微信服务器向后端服务器回调扫码事件，由于前端无法感知到用户手机扫码的行为，所以停留在扫码登陆页面时需要持续轮询后端服务器用户是否已扫码登录，造成服务器的较大压力，于是利用Servlet3.0的异步特性，实现长轮询的方式来通信。
前端扫码登录页面请求后端微信二维码，后端返回微信二维码给前端时附带随机生成的scene_id，前端显示二维码供用户手机微信扫码，前端持续轮询后端用户是否已扫码（上一次轮询未成功登陆为开启下一次轮询的条件），但需带上scene_id以区分扫码用户，此时后端不同步返回前端请求结果，而是以异步响应式的方式等待微信服务器回调后，或是超过指定时间例如30秒后再返回（可能用户打开登陆页面后停留但未成功扫码），大大减少了前端访问后端的次数。
具体方式是，request对象通过startAsync()方法获得异步域对象AsyncContext，此时请求被挂起，并释放Servlet线程。请求异步域对象AsyncContext放入ConcurrentHashMap实现的请求池中，以scene_id为key。
微信服务器回调服务端时会带上扫码事件（登陆为scan，关注为subscribe）以及scene_id、openid，将回调数据包装为响应事件放入响应事件队列中。
使用一个守护线程监听该队列，以阻塞的方式获取队列中的响应事件对象，并调用自定义线程池，根据scene_id从请求池中找到还未响应返回的AsyncContext对象，并从中获得response对象，根据JSON对象中的openId查询到用户信息，然后返回给前端。
如果30s超时后仍未接收到微信服务器的回调，则超时返回响应前端。
相比普通定时轮询，由于采用响应式设计，可以大幅降低前端请求频率和服务器负载，并在事件发生后第一时间通知前端，没有轮询周期空挡导致的延迟，相比websocket则可以并避免浏览器版本过低、网关对长连接的兼容性等问题，实现上也更加简单。

5.1 案例Demo

 

java
 

代码解读
 

复制代码
 

@RestController @RequestMapping("/longPolling") @Slf4j public class LongPollingController { //发送长轮询请求示例 @GetMapping("/poll/{requestId}") public void poll(HttpServletRequest request, @PathVariable String requestId) { //启动长轮询，设置 AsyncTaskUtil.longPolling(request ,requestId, 30); } //触发长轮询立即回复事件 @GetMapping("/call/{requestId}/{content}") public void call(@PathVariable String requestId,@PathVariable String content) { AsyncTaskUtil.addLongPollingRespEvent(requestId,() -> { return R.ok("处理后结果："+content); }); } //模拟tomcat容器线程阻塞 @GetMapping("/block/{resp}") public String test(@PathVariable String resp) throws InterruptedException { log.info("进入test controller---resp={},thread={}",resp,Thread.currentThread().getName()); Thread.currentThread().sleep(10000); return resp; } } 
 

 

java
 

代码解读
 

复制代码
 

package com.tsd.dlmPlatform_common.util; import com.alibaba.fastjson.JSON; import com.tsd.dlmPlatform_common.constant.ExceptionEnum; import com.tsd.dlmPlatform_common.responseEntity.R; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.context.annotation.DependsOn; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import javax.servlet.AsyncContext; import javax.servlet.ServletResponse; import javax.servlet.http.HttpServletRequest; import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.concurrent.*; import java.util.function.Supplier; /** * * @author HeJun * @date 2021-10-25 * @Version V1.0 * @Description 异步任务执行工具类 */ @Slf4j @Component @DependsOn("contextUtil") public class AsyncTaskUtil { public static final int PROCESSOR_NUM = Runtime.getRuntime().availableProcessors(); private static final String EXECUTOR = "MY_EXECUTOR"; private static final int KEEP_ALIVE_SECONDS = 60; public static final String SUCESS_RESP_STR = "执行成功"; private static final RejectedExecutionHandler MY_REJECTED_EXECUTION_HANDLER = ContextUtil .getBean("myRejectedExecutionHandler", RejectedExecutionHandler.class); private static volatile Map<String, ThreadPoolExecutor> THREAD_POOL_EXECUTOR_MAP = new ConcurrentHashMap<>(); private static volatile Map<String, AsyncContext> ASYNC_CONTEXT_MAP = new ConcurrentHashMap<>(); private static final LinkedBlockingDeque<LongPollingEvent<?>> LONG_POLLING_EVENT_QUEUE = new LinkedBlockingDeque<>(); private static final ScheduledThreadPoolExecutor TIME_OUT_CHECKER = new ScheduledThreadPoolExecutor(PROCESSOR_NUM,MY_REJECTED_EXECUTION_HANDLER); /** * * @author HeJun * @date 2021-10-25 * @Version V1.0 * @Description Bean销毁前关闭线程池 */ @PreDestroy private void destroyExecutor() { log.info("关闭线程池。。。。。。。"); for (ThreadPoolExecutor executor : THREAD_POOL_EXECUTOR_MAP.values()) { executor.shutdown(); } TIME_OUT_CHECKER.shutdown(); } @PostConstruct private void init() { ThreadPoolTaskExecutor threadPoolTaskExecutor = ContextUtil.getBean(EXECUTOR, ThreadPoolTaskExecutor.class); if(threadPoolTaskExecutor == null){ getOrAddThreadPoolExecutor(EXECUTOR,PROCESSOR_NUM,2*PROCESSOR_NUM,500,KEEP_ALIVE_SECONDS,true); }else { THREAD_POOL_EXECUTOR_MAP.put(EXECUTOR, threadPoolTaskExecutor.getThreadPoolExecutor()); } } /** * * @author HeJun * @date 2022-05-06 * @Version V1.0 * @Description 返回单例定时器线程池 * @return */ public static ScheduledThreadPoolExecutor getTimeOutChecker(){ return TIME_OUT_CHECKER; } /** * * @author HeJun * @date 2021-12-18 * @Version V1.0 * @Description 使用默认线程池执行有返回值的任务，不阻塞当前线程，可抛出异常，队列满则拒绝并抛出异常 * @param <T> * @param supplier * @return */ public static <T> CompletableFuture<T> supplyAsync(Supplier<T> supplier) { return supplyAsync(supplier, EXECUTOR, 0, 0, 0, 0,true); } /** * * @author HeJun * @date 2021年4月28日 * @Version V1.0 * @Description 使用指定参数的线程池执行有返回值的任务，不阻塞当前线程，可抛出异常，用于隔离接口执行任务的线程池，避免单一接口拖垮整个系统，限制并发线程数提高执行效率 * @param <T> * @param supplier * @param poolName * @param concurrency * @param maxConcurrency * @param queueSize * @param isRejected 队列满是否拒绝任务，并抛出拒绝任务异常 * @return */ public static <T> CompletableFuture<T> supplyAsync(Supplier<T> supplier,String poolName,int concurrency,int maxConcurrency,int queueSize,int keepAliveSeconds,boolean isRejected) { if(poolName == null) { poolName = EXECUTOR; } ThreadPoolExecutor threadPoolExecutor = getOrAddThreadPoolExecutor(poolName, concurrency,maxConcurrency, queueSize,keepAliveSeconds,isRejected); return CompletableFuture.supplyAsync(supplier, threadPoolExecutor); } /** * * @author HeJun * @date 2021年9月24日 * @Version V1.0 * @Description 批量向线程池添加任务，并返回任务的异常信息 * @param poolName * @param concurrency * @param maxConcurrency * @param queueSize * @param isRejected * @param sucessRespStr 任务正常运行没有抛出异常时返回的字符串 * @param task 返回任务集合的总任务 * @param timeoutSeconds 任务超时时间 * @return * */ public static List<String> supplyAsyncAllWithExceptionMsgBatch(Supplier<List<Supplier<String>>> task,int timeoutSeconds,String poolName,int concurrency,int maxConcurrency,int queueSize,boolean isRejected,String sucessRespStr) { if(sucessRespStr == null) { throw new RuntimeException("正确回复模板不能为空"); } List<CompletableFuture<String>> futureList = new ArrayList<>(); List<String> exMsgList = new ArrayList<>(); supplyAsync(task).thenAccept(supplierList -> { for (Supplier<String> supplier : supplierList) { CompletableFuture<String> supplyAsync = supplyAsyncWithExceptionMsg(supplier, poolName, concurrency, maxConcurrency, queueSize, isRejected); futureList.add(supplyAsync); } }).join(); for (CompletableFuture<String> completableFuture : futureList) { String result = null; try { result = completableFuture.get(timeoutSeconds,TimeUnit.SECONDS); } catch (InterruptedException | ExecutionException | TimeoutException e) { result = "任务执行超时"; } if(!sucessRespStr.equals(result)) { exMsgList.add(result); } } return exMsgList; } /** * * @author HeJun * @date 2021年9月24日 * @Version V1.0 * @Description 批量向线程池添加任务，并返回任务的异常信息 * @param task * @param sucessRespStr 任务正常运行没有抛出异常时返回的字符串 * @return * */ public static List<String> supplyAsyncAllWithExceptionMsgBatch(Supplier<List<Supplier<String>>> task, String sucessRespStr) { return supplyAsyncAllWithExceptionMsgBatch(task, 10, EXECUTOR, 0, 0, 0, true, sucessRespStr); } /** * * @author HeJun * @date 2021年9月24日 * @Version V1.0 * @Description 提交任务到线程池，并返回异常信息 * @param supplier * @param poolName * @param concurrency * @param maxConcurrency * @param queueSize * @param isRejected * @return * */ public static CompletableFuture<String> supplyAsyncWithExceptionMsg(Supplier<String> supplier,String poolName,int concurrency,int maxConcurrency,int queueSize,boolean isRejected){ return supplyAsync(supplier, poolName, concurrency, maxConcurrency, queueSize, KEEP_ALIVE_SECONDS,isRejected) .exceptionally(t -> t.getCause() == null ? t.getMessage() : t.getCause().getMessage()); } /** * * @author HeJun * @date 2020-12-18 * @Version V1.0 * @Description 使用指定参数的线程池执行无返回值的任务，不阻塞当前线程，不可抛出异常 * @param runnable * @return */ public static CompletableFuture<Void> runAsync(Runnable runnable,String poolName,int concurrency,int maxConcurrency,int queueSize,int keepAliveSeconds,boolean isReject) { ThreadPoolExecutor threadPoolExecutor = getOrAddThreadPoolExecutor(poolName, concurrency,maxConcurrency, queueSize,keepAliveSeconds,isReject); return CompletableFuture.runAsync(runnable, threadPoolExecutor); } /** * * @author HeJun * @date 2020-12-18 * @Version V1.0 * @Description 使用默认线程池执行无返回值的任务，不阻塞当前线程，不可抛出异常 * @param runnable * @return */ public static CompletableFuture<Void> runAsync(Runnable runnable) { return runAsync(runnable,EXECUTOR,0,0,0,0,true); } /** * * @author HeJun * @date 2021年4月28日 * @Version V1.0 * @Description 获得指定名字的线程池，不存在则创建，线程安全 * @param poolName * @param concurrency * @param queueSize * @param isRecject 队列已满是否拒绝 * @return */ public static ThreadPoolExecutor getOrAddThreadPoolExecutor(String poolName,int concurrency,int maxConcurrency,int queueSize,int keepAliveSecsonds,boolean isRecject) { ThreadPoolExecutor threadPoolExecutor = THREAD_POOL_EXECUTOR_MAP.get(poolName); if(threadPoolExecutor == null) { synchronized (poolName.intern()){ // 双检锁 threadPoolExecutor = THREAD_POOL_EXECUTOR_MAP.get(poolName); if(threadPoolExecutor == null){ // 生成一个指定参数表的线程池对象 RejectedExecutionHandler rejectedExecutionHandler = isRecject ? MY_REJECTED_EXECUTION_HANDLER : new ThreadPoolExecutor.CallerRunsPolicy(); keepAliveSecsonds = keepAliveSecsonds == 0 ? KEEP_ALIVE_SECONDS : keepAliveSecsonds; threadPoolExecutor = new ThreadPoolExecutor(concurrency, maxConcurrency, keepAliveSecsonds, TimeUnit.SECONDS, new LinkedBlockingDeque<>(queueSize), rejectedExecutionHandler); // 放入线程池单例map中 THREAD_POOL_EXECUTOR_MAP.put(poolName, threadPoolExecutor); } } } return threadPoolExecutor; } /** * * @author HeJun * @date 2020年5月14日 * @Version V1.0 * @Description 长轮询 * @param request * @param requestId * @param timeOutSeconds */ public static void longPolling(HttpServletRequest request, String requestId, long timeOutSeconds) { //请求异步域对象 AsyncContext asyncContext = request.startAsync(); //关闭长轮询自动超时处理 asyncContext.setTimeout(0); //消息等待map添加异步域对象 ASYNC_CONTEXT_MAP.put(requestId, asyncContext); //注册长轮询超时未响应兜底任务 TIME_OUT_CHECKER.schedule(() -> { try { writePollingResponse(requestId, R.error(ExceptionEnum.POLLING_TIME_OUT)); } catch (IOException e) { log.error(e.getMessage(), e); } }, timeOutSeconds,TimeUnit.SECONDS); } /** * 添加长轮询立即响应触发事件 * @param <T> * @param requestId * @param task * @return */ public static <T> boolean addLongPollingRespEvent(String requestId, LongPollingTask<T> task) { return LONG_POLLING_EVENT_QUEUE.add(new LongPollingEvent<T>(requestId, task)); } /** * 长轮询触发响应事件类 * @param <T> */ @Data @AllArgsConstructor @NoArgsConstructor static class LongPollingEvent<T> { // AsyncContext对象id private String requestId; // 待处理内容的处理任务 private LongPollingTask<T> task; } /** * 待处理内容的处理任务接口 * @param <T> */ public static interface LongPollingTask<T> { R<T> execute(); } /** * * @author HeJun * @date 2021年4月28日 * @Version V1.0 * @Description 获得指定名字的线程池，不存在则创建，线程安全 * @param requestId * @param resp * @return */ private static void writePollingResponse(String requestId, R<?> resp) throws IOException { if (ASYNC_CONTEXT_MAP.get(requestId) != null) { synchronized (requestId.intern()){ AsyncContext asyncContext = ASYNC_CONTEXT_MAP.get(requestId); if (asyncContext != null) { log.info("事件触发长轮询回复----,requestId={},resp={}",requestId,resp); ServletResponse response = asyncContext.getResponse(); response.setContentType("application/json;charset=utf-8"); response.setCharacterEncoding("utf-8"); response.getWriter().append(JSON.toJSONString(resp)); asyncContext.complete(); ASYNC_CONTEXT_MAP.remove(requestId); }else { log.info("长轮询已回复，超时回复终止----,requestId={},resp={}",requestId,resp); } } }else { log.info("长轮询已回复，超时回复终止----,requestId={},resp={}",requestId,resp); } } /** * 长轮询事件触发后的处理守护线程，监听长轮询立即回复事件队列 */ static { Thread thread = new Thread(() -> { while (true) { try { LongPollingEvent pollingEvent = LONG_POLLING_EVENT_QUEUE.take(); runAsync(() -> { try { R<?> resp = pollingEvent.getTask().execute(); writePollingResponse(pollingEvent.getRequestId(), resp); } catch (Exception e) { log.error(e.getMessage(), e); } }); } catch (InterruptedException e) { log.error(e.getMessage(), e); } } }); thread.setDaemon(true); thread.start(); } } 
 

_
 

 

java
 

代码解读
 

复制代码
 

@Data @ApiModel("R统一返回结果对象") @SuppressWarnings("unchecked") @Slf4j public class R<T> { @ApiModelProperty("是否成功") private Boolean success; @ApiModelProperty("返回码") private Integer code; @ApiModelProperty("返回消息") private String message; @ApiModelProperty("返回数据") private T data; public static <T> R<T> error() { R<T> r = new R<T>(); r.setSuccess(false); r.setCode(ExceptionEnum.ERROR.getCode()); r.setMessage(ExceptionEnum.ERROR.getMessage()); return r; } public static <T> R<T> error(String message) { R<T> r = new R<T>(); r.setSuccess(false); r.setCode(ExceptionEnum.ERROR.getCode()); r.setMessage(message); return r; } public static <T> R<T> error(ExceptionEnum e) { R<T> r = new R<T>(); r.setSuccess(false); r.setCode(e.getCode()); r.setMessage(e.getMessage()); return r; } public static <T> R<T> ok() { R<T> r = new R<T>(); r.setSuccess(true); r.setCode(ExceptionEnum.SUCCESS.getCode()); r.setMessage(ExceptionEnum.SUCCESS.getMessage()); return r; } public static <T> R<T> ok(T data) { R<T> r = new R<T>(); r.setSuccess(true); r.setCode(ExceptionEnum.SUCCESS.getCode()); r.setMessage(ExceptionEnum.SUCCESS.getMessage()); r.setData(data); return r; } public R<T> message(String message) { this.setMessage(message); return this; } public R<T> code(Integer code) { this.setCode(code); return this; } } 
 

 

java
 

代码解读
 

复制代码
 

public enum ExceptionEnum { SUCCESS(200,"成功"), USER_INPUT_ERROR(400,"用户输入错误"), SYSTEM_ERROR(500,"系统异常"), INNER_ERROR(600,"业务异常"), ERROR(999,"失败"), USER_NOT_EXIST(701,"用户名不存在"), PASSWORD_ERROR(702,"密码错误"), USER_NOT_ENABLED(703,"用户被禁用"), WITHOUT_LOGIN(704,"未携带授权凭证"), USER_EXIST(705,"用户名已存在"), VERIFYCODE_ERRO(706,"验证码错误"), DATA_FORMAT_ERRO(707,"数据格式错误"), USER_NOT_EXAMINE(708,"账号待审核"), USER_FAIL_EXAMINE(709,"账号审核失败"), POLLING_TIME_OUT(710,"长轮询暂无数据"), AUTHORITY_DENIED(401,"无此权限"), IP_DENIED(402,"该IP已被禁用，请联系管理员"), ACCESS_DENIED(403,"未登录"), TOKEN_EXPIRED(405,"登陆已过期"); private int code; private String message; ExceptionEnum(int code,String message) { this.code = code; this.message = message; } public int getCode() { return code; } public String getMessage() { return message; } } 

                

        

    

  



    



                



	

		

			

				
					
程序员架构修炼之道：如何设计“易理解”的系统架构？

				
			

			

				

					AI天才研究院
				

				

					07-31
					
					9850
					
				

			

		

		

			
				
前言尽管“可靠性”有时被视为“可用性”的同义词，但这一属性实际上意味着系统的所有关键设计的保证：可用性、持久性和安全不变量等。我们构建易于理解的系统的主要指导思想是，使用清晰的、有约束的组件来构造系统。其中一些组件可能构成其可信计算的基础，因此可以集中解决安全风险。为了对系统的安全态势及其实现服务等级目标的能力有信心，你需要管理系统的复杂性：必须让系统、组件及其之间的交互...

			
		

	



                

            
              



	

		

			

				
					
BAT 大厂Java 面试题集锦之核心篇附参考答案

				
			

			

				

					AI天才研究院
				

				

					11-05
					
					1万+
					
				

			

		

		

			
				
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...

			
		

	



              


  
              

                


	

		

			

				
					
http长轮询技术comet的实现

				
			

			

				

					09-20
				

			

		

		

			
				
通过comet实现了一个聊天功能。
1.需要在tomcat的server.xml里面配置
  
2.需要在tomcat的context.xml里面配置
在Context标签里面配置：


			
		

	





	

		

			

				
					
WebSocket和长轮询

					
最新发布

				
			

			

				

					m0_50742275的博客
				

				

					03-17
					
					793
					
				

			

		

		

			
				
WebSocket和长轮询

			
		

	



		

			
		



	

		

			

				
					
实现一个简单的长轮询

				
			

			

				

					m0_57042151的博客
				

				

					09-12
					
					1956
					
				

			

		

		

			
				
现在各大中间件都使用了长轮询的数据交互方式，目前比较流行的例如Nacos的配置中心，RocketMQ Pull(拉模式)消息等，它们都是采用了长轮询方的式实现。还会造成推送数据的延迟，比如：每10s请求一次配置，如果在第11s时配置更新了，那么推送将会延迟9s，等待下一次请求；为了解决短轮询存在的问题，客户端发起长轮询，如果服务端的数据没有发生变更，会hold住请求，直到服务端的数据发生变化，或者等待一定时间超时才会返回。降低轮询的间隔，延迟降低，压力增加；增加轮询的间隔，压力降低，延迟增高。

			
		

	





	

		

			

				
					
长轮询实现方式（fetch，sse）

				
			

			

				

					DT_11的博客
				

				

					03-13
					
					1023
					
				

			

		

		

			
				
长轮询（Long Polling）是一种用于实现实时数据传输的技术。它通过建立持久的连接，使服务器能够即时地将数据发送给客户端，而无需客户端不断地主动发送请求。传统的短轮询（Short Polling）方式中，客户端通过定期发送请求来获取服务器上的最新数据。这样会导致频繁的请求和响应，增加了网络流量和服务器负载，并且延迟较高。长轮询通过将客户端的请求保持在服务器端，直到有新数据可用或达到一定的超时时间，然后再返回响应给客户端。如果在超时之前有新数据可用，服务器会立即返回响应；

			
		

	





	

		

			

				
					
长轮询解决方案

					
热门推荐

				
			

			

				

					chszs的专栏
				

				

					06-21
					
					1万+
					
				

			

		

		

			
				
长轮询解决方案作者：chszs，转载需注明。博客主页：http://blog.youkuaiyun.com/chszs长轮询适合浏览器的Chat聊天、股票行情显示、股票状态更新、体育直播的结果显示等。当然，不是所有的例子都是对延迟很敏感的，但它们的需求都比较相似。
在标准的HTTP请求响应语义中，浏览器发起请求，服务器发送一个响应，这意味着在浏览器发起新请求前，服务器不能发送新信息给客户端浏览器。有几种解决方法

			
		

	





	

		

			

				
					
图文字浅谈--计算机网络常遇的面试问题(计网面经)

				
			

			

				

					某不知名菜鸟的博客
				

				

					03-10
					
					3160
					
				

			

		

		

			
				
学习计算机网络准备面试的同时做了一些笔记，分享出来希望能够帮助大家快速掌握计算机网络常遇到的问题。
笔记主要选自《图解HTTP》与《图解TCP/IP》以及网络面经，由于本人也是处于学习阶段，同时笔记是Word转MD上传，格式与知识点有误处望请指正。

计算机网络
一、协议层次以及服务类型

OSI七层模型

开放式通信系统互联参考模型 每一层实现各自的功能和协议，并完成相邻层的接口通信 某一层的服务就是该层以及其下各层的一种能力

1.应用层

通过应用程序间的交互来完成特定的网络应用。 协议定义了应用进.

			
		

	





	

		

			

				
					
浅谈netty的诞生历程

				
			

			

				

					爱学习的小白
				

				

					11-22
					
					1680
					
				

			

		

		

			
				
从简单的tcp连接到高并发，高稳定性的netty，都经历了什么？

			
		

	





	

		

			

				
					
用Webhook+Python+Shell 编写一套 Unix 类系统监控工具

				
			

			

				

					GitChat
				

				

					07-03
					
					4278
					
				

			

		

		

			
				
告警系统是系统运维必须掌握的技能、不管是用 Zabbix、Cacti 等监控平台还是其他的监控工具，都需要有一个实时的监控与反馈机制，能让问题、故障实时的通知到工程师的手里，及时得到解决；以最大化的保障业务的正常。
这次总结部署监控是为了更好的学习、经验的总结、也希望能给各位带来一点帮助，在大家刚好需要的时候，这篇文章或许会给你不一样的方便！
Webhook+Python+Shell 编写一套强大...

			
		

	





	

		

			

				
					
web即时聊天(ajax长轮询方式实现)

				
			

			

				

					02-20
				

			

		

		

			
				
采用ajax＋长轮询，简单易懂．实现web对话即时推送。欢迎下载！

			
		

	





	

		

			

				
					
asp.net+jquery长轮询实例

				
			

			

				

					08-02
				

			

		

		

			
				
完整长轮询代码，客户端使用jquery访问后台程序，后台hold住此连接，实时监控数据变化，有变化则返回结果到客户端。此代码使用了异步回调以保证主进程不会形成阻塞。

			
		

	





	

		

			

				
					
PHP+Jquery  实现长轮询案例

				
			

			

				

					08-27
				

			

		

		

			
				
WEB IM 怎么实现的，这里面都讲到哦！

			
		

	





	

		

			

				
					
长轮询（Long Polling）实现原理和java代码示例

				
			

			

				

					zzz19920821的博客
				

				

					07-18
					
					1347
					
				

			

		

		

			
				
长轮询是一种在Web开发中常用的技术，用于实现服务器与客户端之间的即时通信或近乎实时的数据交换。这种方式效率较低，尤其是在数据更新不频繁的情况下，会造成不必要的网络请求和服务器负载。在长轮询中，当服务器没有新数据时，服务器会保持连接开启并挂起请求，直到有新数据到达或达到一定的超时时间。一旦有新数据或超时，服务器就会响应客户端，客户端接收到响应后立即发起新的长轮询请求。：上面的代码示例仅用于说明长轮询的概念和可能的实现方式，并未直接使用WebSocket或任何异步框架来实现真正的长轮询。

			
		

	





	

		

			

				
					
长轮询 Servlet实现

				
			

			

				

					wwhhff11
				

				

					10-11
					
					2827
					
				

			

		

		

			
				
长轮询@RequestMapping("/ajax")
public void ajax(long timed, HttpServletResponse response) throws Exception {
     PrintWriter writer = response.getWriter();     Random rand = new Random();
     // 死循环 查询有

			
		

	





	

		

			

				
					
如何实施基本的“长轮询”？

				
			

			

				

					p15097962069的博客
				

				

					12-20
					
					708
					
				

			

		

		

			
				
我可以找到很多关于Long Polling如何工作的信息（例如， 这个和这个 ），但没有关于如何在代码中实现它的简单示例。 
  我所能找到的只是依赖于Dojo JS框架的cometd ，以及一个

			
		

	





	

		

			

				
					
前端（二十三）——轮询和长轮询

				
			

			

				

					杜永康的博客
				

				

					10-25
					
					8985
					
				

			

		

		

			
				
现代Web应用程序对实时通信的需求越来越高，为了满足这种需求，轮询和长轮询成为了常用的技术手段。本文将深入探讨轮询和长轮询的实现原理、优缺点以及使用场景，并提供代码示例，以帮助读者更好地理解和应用这两种技术。

			
		

	





	

		

			

				
					
AsyncContext优雅实现HTTP长轮询接口

				
			

			

				

					大猩猩的博客
				

				

					09-04
					
					1969
					
				

			

		

		

			
				
接到一个需求，实现方案时需要提供一个HTTP接口，接口需要hold住5-8秒，轮询查询数据库，一旦数据库中值有变化，取出变化的值进行处理，处理完成后返回响应。长时间运行的操作：当我们需要执行一些耗时的操作，例如网络请求、数据库查询或其他 I/O 操作时，通过将这些操作放在一个新的线程中，可以避免阻塞 servlet 容器中的线程，提高应用的并发性能。总结来说，Spring 的 AsyncContext 提供了方便的异步处理机制，可以提高应用的并发性能，并支持推送异步响应，使得应用更具有响应性和可伸缩性。

			
		

	





	

		

			

				
					
详解前端长轮询

				
			

			

				

					实战大师
				

				

					12-02
					
					776
					
				

			

		

		

			
				
详解前端长轮询

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值