Servlet 3.0异步处理可将服务器吞吐量提高十倍

Servlet是Java中处理服务器端逻辑的主要组件,新的3.0规范引入了一些非常有趣的功能,其中异步处理是最重要的功能之一。 可以利用异步处理来开发高度可伸缩的Web应用程序。 使用此功能可以有效地构建Web 2.0站点和AJAX应用程序。

我们的JCG合作伙伴之一Tomasz Nurkiewicz最近写了一篇非常不错的文章, 介绍如何使用异步处理来提高服务器的吞吐量 。 让我们找出他是如何做到的。

(注意:对原始帖子进行了少量编辑以提高可读性)

Java servlet容器并不特别适合处理大量并发用户,这不是秘密。 通用的每请求线程数模型有效地将并发连接数限制为JVM可以处理的并发运行线程数。 而且,由于每个新线程都会显着增加内存占用量和CPU利用率(上下文切换),因此处理100-200个以上的并发连接在Java中似乎是一个荒谬的想法。 至少在Servlet 3.0之前的时代。

在本文中,我们将编写一个具有速度限制的可伸缩且健壮的文件服务器。 在第二个版本中,利用Servlet 3.0异步处理功能,我们将能够使用更少的线程来处理10倍大的负载。 无需额外的硬件,只需做出一些明智的设计决策即可。

令牌桶算法

建立文件服务器,我们必须自觉地管理我们的资源,尤其是网络带宽。 我们不希望单个客户端消耗全部流量,我们甚至可能希望根据用户,一天中的时间等在运行时动态限制下载限制-当然,所有操作都在高负载下发生。 开发人员喜欢重新发明轮子,但是我们的所有要求已经通过简单的令牌桶算法解决了 。

Wikipedia中的解释非常好,但是由于我们会根据需要对算法进行一些调整,因此这里的描述更加简单。 首先有一个水桶。 在这个桶里有统一的令牌。 每个令牌价值20 kiB(我将使用我们应用程序中的实际值)的原始数据。 客户端每次请求文件时,服务器都会尝试从存储桶中获取一个令牌。 如果成功,他将20 kiB发送给客户端。 重复最后两个句子。 如果服务器由于存储桶已经为空而无法获取令牌,该怎么办? 他在等。

那么代币从哪里来呢? 后台进程不时充满水桶。 现在变得清楚了。 如果此后台进程每100毫秒(每秒10次)添加100个新令牌,每个令牌价值20 kiB,则服务器最多可以发送20 MiB / s(100乘以20 kiB乘以10),在所有客户端之间共享。 当然,如果存储桶已满(1000个令牌),则将忽略新令牌。 这非常好用–如果存储桶为空,则客户正在等待下一个存储桶填充周期; 通过控制存储桶容量,我们可以限制总带宽。

言归正传,我们对令牌桶的简化实现是从一个接口开始的(整个源代码可在GitHub的global-bucket分支中找到):

public interface TokenBucket {int TOKEN_PERMIT_SIZE = 1024 * 20;void takeBlocking() throws InterruptedException;void takeBlocking(int howMany) throws InterruptedException;boolean tryTake();boolean tryTake(int howMany);}

takeBlocking()方法同步等待令牌可用,而tryTake()仅在令牌可用时接受令牌,如果采用则立即返回true,否则返回false。 幸运的是,术语存储桶只是一个抽象:因为令牌是无法区分的,我们需要实现的所有操作都是存储桶,它是一个整数计数器。 但是,由于存储桶本质上是多线程的,并且涉及一些等待,因此我们需要更复杂的机制。 信号量似乎几乎是理想的:

@Service
@ManagedResource
public class GlobalTokenBucket extends TokenBucketSupport {private final Semaphore bucketSize = new Semaphore(0, false);private volatile int bucketCapacity = 1000;public static final int BUCKET_FILLS_PER_SECOND = 10;@Overridepublic void takeBlocking(int howMany) throws InterruptedException {bucketSize.acquire(howMany);}@Overridepublic boolean tryTake(int howMany) {return bucketSize.tryAcquire(howMany);}}

信号量完全符合我们的要求。 bucketSize表示存储桶中当前的令牌数量。 另一方面,bucketCapacity限制了存储桶的最大大小。 它是易变的,因为可以通过JMX对其进行修改(可见性):

@ManagedAttribute
public int getBucketCapacity() {return bucketCapacity;
}@ManagedAttribute
public void setBucketCapacity(int bucketCapacity) {isTrue(bucketCapacity >= 0);this.bucketCapacity = bucketCapacity;
}

如您所见,我正在使用Spring及其对JMX的支持。 Spring框架在此应用程序中不是绝对必要的,但是它带来了一些不错的功能。 例如,实现一个定期填充存储桶的后台进程如下所示:

@Scheduled(fixedRate = 1000 / BUCKET_FILLS_PER_SECOND)
public void fillBucket() {final int releaseCount = min(bucketCapacity / BUCKET_FILLS_PER_SECOND, bucketCapacity - bucketSize.availablePermits());bucketSize.release(releaseCount);
}

这段代码包含主要的多线程错误,出于本文的目的,我们可以将其忽略。 假设将水桶装满最大值–它会一直工作吗?

此外,这是使@Scheduled批注起作用所需的XML代码段(applicationContext.xml):

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:context="http://www.springframework.org/schema/context"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:task="http://www.springframework.org/schema/task"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"><context:component-scan base-package="com.blogspot.nurkiewicz.download" /><context:mbean-export/><task:annotation-driven scheduler="bucketFillWorker"/><task:scheduler id="bucketFillWorker" pool-size="1"/></beans>

具有令牌桶抽象和非常基本的实现,我们可以开发实际的servlet返回文件。 我总是返回大小几乎为200 kiB的相同固定文件):

@WebServlet(urlPatterns = "/*", name="downloadServletHandler")
public class DownloadServlet extends HttpRequestHandlerServlet {}@Service
public class DownloadServletHandler implements HttpRequestHandler {private static final Logger log = LoggerFactory.getLogger(DownloadServletHandler.class);@Resourceprivate TokenBucket tokenBucket;@Overridepublic void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {final File file = new File("/home/dev/tmp/ehcache-1.6.2.jar");final BufferedInputStream input = new BufferedInputStream(new FileInputStream(file));try {response.setContentLength((int) file.length());sendFile(request, response, input);} catch (InterruptedException e) {log.error("Download interrupted", e);} finally {input.close();}}private void sendFile(HttpServletRequest request, HttpServletResponse response, BufferedInputStream input) throws IOException, InterruptedException {byte[] buffer = new byte[TokenBucket.TOKEN_PERMIT_SIZE];final ServletOutputStream outputStream = response.getOutputStream();for (int count = input.read(buffer); count > 0; count = input.read(buffer)) {tokenBucket.takeBlocking();outputStream.write(buffer, 0, count);}}
}

这里使用了HttpRequestHandlerServlet 。 尽可能简单:读取20 kiB的文件,从存储桶中获取令牌(如果不可用,则等待),将块发送到客户端,重复直到文件结束。

信不信由你,这实际上有效! 无论有多少个(或几个)客户端同时访问该servlet,总的传出网络带宽都不会超过20 MiB! 该算法有效,希望您对如何使用它有一些基本的了解。 但是,让我们面对现实吧-全局限制太不灵活,有点of脚-单个客户端实际上可以消耗您的整个带宽。

那么,如果我们为每个客户有一个单独的存储桶怎么办? 而不是一个信号量–地图? 每个客户端都有单独的独立带宽限制,因此没有饥饿的风险。 但是还有更多:

一些客户可能有更大的特权,甚至没有更大的限制,甚至根本没有限制,
有些可能被列入黑名单,从而导致连接被拒绝或吞吐量非常低
禁止IP,要求身份验证,Cookie /用户代理验证等。 我们可能会尝试关联来自同一客户端的并发请求,并对所有请求使用相同的存储桶,以免通过打开多个连接而作弊。 我们也可能拒绝后续连接 以及更多…

我们的存储桶接口不断增长,允许实现利用新的可能性(请参阅分支per-request-synch ):

public interface TokenBucket {void takeBlocking(ServletRequest req) throws InterruptedException;void takeBlocking(ServletRequest req, int howMany) throws InterruptedException;boolean tryTake(ServletRequest req);boolean tryTake(ServletRequest req, int howMany);void completed(ServletRequest req);
}public class PerRequestTokenBucket extends TokenBucketSupport {private final ConcurrentMap<Long, Semaphore> bucketSizeByRequestNo = new ConcurrentHashMap<Long, Semaphore>();@Overridepublic void takeBlocking(ServletRequest req, int howMany) throws InterruptedException {getCount(req).acquire(howMany);}@Overridepublic boolean tryTake(ServletRequest req, int howMany) {return getCount(req).tryAcquire(howMany);}@Overridepublic void completed(ServletRequest req) {bucketSizeByRequestNo.remove(getRequestNo(req));}private Semaphore getCount(ServletRequest req) {final Semaphore semaphore = bucketSizeByRequestNo.get(getRequestNo(req));if (semaphore == null) {final Semaphore newSemaphore = new Semaphore(0, false);bucketSizeByRequestNo.putIfAbsent(getRequestNo(req), newSemaphore);return newSemaphore;} else {return semaphore;}}private Long getRequestNo(ServletRequest req) {final Long reqNo = (Long) req.getAttribute(REQUEST_NO);if (reqNo == null) {throw new IllegalAccessError("Request # not found in: " + req);}return reqNo;}}

实现非常相似( 此处为全类),只不过单个信号量已被map取代。 由于各种原因,我没有将请求对象本身用作映射键,而是在接收新连接时手动分配的唯一请求号。 调用completed()非常重要,否则映射将持续增长,从而导致内存泄漏。 总而言之,令牌桶的实现没有太大变化,下载servlet几乎相同(除了将请求传递给令牌桶)。 我们现在准备进行压力测试!

吞吐量测试

为了进行测试,我们将JMeter与这套出色的插件结合使用 。 在20分钟的测试过程中,我们对服务器进行预热,每6秒启动一个新线程(并发连接),以在10分钟后达到100个线程。 在接下来的十分钟内,我们将保持100个并发连接,以查看服务器的工作稳定性。 以下是一段时间内的活动线程:

重要说明 :在Tomcat(已测试7.0.10)中,我人为地将HTTP工作线程的数量减少到10 。 这与实际配置相差甚远,但是我想强调一些与服务器功能相比在高负载下发生的现象。 使用默认池大小,我将需要几台运行分布式JMeter会话的客户端计算机以生成足够的流量。 如果您在云中有一个服务器场或几个服务器(与我3岁的笔记本电脑相对),我将很高兴在更现实的环境中看到结果。

记住Tomcat中有多少个HTTP工作线程可用,随着时间的推移响应时间就远远不能令人满意:

请注意测试开始时的平稳期:大约一分钟后(提示:当并发连接数超过10时),响应时间激增,在10分钟(并发连接数达到100)后稳定在10秒左右。 再次:100个工作线程和1000个并发连接会发生相同的行为–这只是规模问题。 响应延迟图(发送请求和接收响应的第一行之间的时间)消除了任何疑问:

在神奇的10个线程数量以下,我们的应用程序几乎立即响应。 这对于客户端来说确实很重要,因为仅接收标头(尤其是Content-Type和Content-Length)可以使标头更准确地告知用户正在发生的事情。 那么Tomcat等待响应的原因是什么? 真的没有魔术。 我们只有10个线程,每个连接都需要一个线程,因此Tomcat(和其他任何其他Servlet 3.0之前的容器)处理10个客户端,而其余90个正在排队。 当十个幸运者之一完成时,就从队列中获得一个连接。 这解释了平均9秒钟的延迟,而Servlet仅需要1秒钟即可处理请求(200 kiB,限制为20 kiB / s)。 如果您仍然不确定,Tomcat提供了不错的JMX指示器,可显示占用了多少线程以及有多少请求排队:

使用传统的servlet,我们无能为力。 吞吐量太可怕了,但是增加线程总数是不可行的(想想:从100增加到1000)。 但是您实际上并不需要探查器来发现线程并不是这里的真正瓶颈。 仔细查看DownloadServletHandler,您认为大部分时间都花在哪里? 正在读取文件? 将数据发送回客户端? 不,servlet等待……然后等待更多。 非有效地挂在信号量上–幸运的是,CPU并未受到损害,但是如果使用繁忙的等待时间来实现呢? 幸运的是,Tomcat 7终于支持了……

Servlet 3.0异步处理

我们已经接近将服务器容量增加一个数量级,但是需要进行一些不重要的更改(请参阅master分支)。 首先,需要将下载servlet标记为异步(好的,这仍然很简单):

@WebServlet(urlPatterns = "/*", name="downloadServletHandler", asyncSupported = true)
public class DownloadServlet extends HttpRequestHandlerServlet {}

主要变化发生在下载处理程序中。 我们不是将整个文件发送到涉及大量等待(takeBlocking())的循环中,而是将循环分为多个单独的迭代,每个迭代都包装在Callable中。 现在,我们将利用一个小的线程池,该线程池将由所有等待的连接共享。 池中的每个任务非常简单:它不等待令牌,而是以非阻塞方式(tryTake())进行请求。 如果令牌可用,则将文件的一部分发送给客户端(sendChunkWorthOneToken())。 如果令牌不可用(存储桶为空),则不会发生任何事情。 无论令牌是否可用,任务都会将自己重新提交到队列中以进行进一步处理(这本质上是非常花哨的多线程循环)。 因为只有一个池,所以该任务降落在队列的末尾,允许服务其他连接。

@Service
public class DownloadServletHandler implements HttpRequestHandler {@Resourceprivate TokenBucket tokenBucket;@Resourceprivate ThreadPoolTaskExecutor downloadWorkersPool;@Overridepublic void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {final File file = new File("/home/dev/tmp/ehcache-1.6.2.jar");response.setContentLength((int) file.length());final BufferedInputStream input = new BufferedInputStream(new FileInputStream(file));final AsyncContext asyncContext = request.startAsync(request, response);downloadWorkersPool.submit(new DownloadChunkTask(asyncContext, input));}private class DownloadChunkTask implements Callable<Void> {private final BufferedInputStream fileInputStream;private final byte[] buffer = new byte[TokenBucket.TOKEN_PERMIT_SIZE];private final AsyncContext ctx;public DownloadChunkTask(AsyncContext ctx, BufferedInputStream fileInputStream) throws IOException {this.ctx = ctx;this.fileInputStream = fileInputStream;}@Overridepublic Void call() throws Exception {try {if (tokenBucket.tryTake(ctx.getRequest())) {sendChunkWorthOneToken();} elsedownloadWorkersPool.submit(this);} catch (Exception e) {log.error("", e);done();}return null;}private void sendChunkWorthOneToken() throws IOException {final int bytesCount = fileInputStream.read(buffer);ctx.getResponse().getOutputStream().write(buffer, 0, bytesCount);if (bytesCount < buffer.length)done();elsedownloadWorkersPool.submit(this);}private void done() throws IOException {fileInputStream.close();tokenBucket.completed(ctx.getRequest());ctx.complete();}}}

我将保留Servlet 3.0 API的详细信息,整个Internet上有许多不太复杂的示例。 只需记住调用startAsync()并使用返回的AsyncContext而不是简单的请求和响应即可。

BTW使用Spring创建线程池非常简单(与Executors和ExecutorService相比,我们得到了不错的线程名称):

没错,一个线程足以服务一百个并发客户端。 自己看看(HTTP工作线程的数量仍然是10,是的,规模以毫秒为单位)。

随着时间的响应时间

随着时间的响应延迟

如您所见,与几乎没有负载的系统相比,一百个客户端同时下载文件时的响应时间仅高5%。 同样,响应延迟不会因增加负载而特别受到损害。 由于硬件资源有限,我无法进一步推动服务器运行,但是我有理由相信这个简单的应用程序可以处理甚至两倍以上的连接:整个测试过程中,HTTP线程和下载工作线程均未得到充分利用。 这也意味着我们甚至不使用所有线程就将服务器容量增加了10倍!

希望您喜欢这篇文章。 当然,并不是每个用例都可以如此轻松地扩展,但是下次您会注意到Servlet主要在等待–不要浪费HTTP线程,而应考虑Servlet 3.0异步处理。 并测试,测量和比较! 完整的应用程序源代码可用(请查看不同的分支),包括JMeter测试计划。

改进领域

还有几个地方需要关注和改进。 如果愿意,请毫不犹豫地进行分叉,修改和测试:

  • 在进行概要分析时,我发现在80%以上的执行中,DownloadChunkTask不会获取令牌,而只会重新计划自身。 这非常浪费CPU时间,可以很轻松地解决(如何?)
  • 考虑在工作线程而不是HTTP线程中打开文件并发送内容长度(在启动异步上下文之前)
  • 如何在每个请求的带宽限制之上实现全局限制? 您至少有两个选择:限制下载工作程序池队列的大小并拒绝执行,或者用重新实现的GlobalTokenBucket(装饰器模式)包装PerRequestTokenBucket
  • TokenBucket.tryTake()方法确实违反了命令查询分离原则。 您能否建议遵循它的外观? 为什么这么难?
  • 我知道我的测试会不断读取相同的小文件,因此对I / O性能的影响很小。 但是在现实生活中,某些缓存层肯定会应用于磁盘存储之上。 因此区别并不大(现在应用程序使用的内存量非常小,很多地方用于缓存)。

得到教训

  • 回送接口并非无限快。 实际上,在我的计算机上,本地主机无法处理80 MiB / s以上的速度。
  • 我不使用普通请求对象作为bucketSizeByRequestNo中的键。 首先,对此接口的equals()和hashCode()没有保证。 更重要的是–阅读下一点...
  • 使用Servlet 3.0处理请求时,必须显式调用completed()刷新和关闭连接。 显然,在调用此方法之后,请求和响应对象是无用的。 Tomcat(在请求对象(池)和其中一些内容用于后续连接)中重用了(这并不明显(我知道为什么很难))。 这意味着以下代码不正确且危险,可能导致访问/破坏其他请求的属性,甚至会话(?!?)
ctx.complete();
ctx.getRequest().getAttribute("SOME_KEY");

而已。 我们的JCG合作伙伴之一Tomasz Nurkiewicz 使用Servlet 3.0异步处理提高服务器吞吐量的非常不错的教程。 别忘了分享!

相关文章:

  • 带有Spring和Maven教程的JAX–WS
  • GWT EJB3 Maven JBoss 5.1集成教程
  • Tomcat 7上具有RESTeasy JAX-RS的RESTful Web服务-Eclipse和Maven项目
  • 正确记录应用程序的10个技巧
  • 每个程序员都应该知道的事情

翻译自: https://www.javacodegeeks.com/2011/03/servlet-30-async-processing-for-tenfold.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/374924.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

使用secureCRT连接VMware-Ubuntukylin虚拟机

使用SecureCRT连接VMware时总是提醒主机拒绝连接。这时可以使用sudo apt-get install openssh-server openssh-client&#xff0c;在主机上安装ssh. 安装成功后&#xff0c;可以连接到主机了。 如果显示远程主机拒绝连接。则可以使用如下方法。 VMware里面装的是Ubuntukylin版本…

加载音频Audio

var cameraAudio new Audio(); cameraAudio.src camera.wav;// 设置音频对象的属性,预加载视频 var options_audio { preload : auto } for(var key in options_audio){ if(options_audio.hasOwnProperty(key) && (key in cameraAudio)){ cameraAudio[key] opti…

习题6-2 使用函数求特殊a串数列和 (20 分)

给定两个均不超过9的正整数a和n&#xff0c;要求编写函数求aaaaaa⋯aa⋯a&#xff08;n个a&#xff09;之和。 int fn( int a, int n ); int SumA( int a, int n );其中函数fn须返回的是n个a组成的数字&#xff1b;SumA返回要求的和。 我的代码&#xff1a; int fn( int a, i…

Java中可怕的双重检查锁定成语

本文讨论的问题不是新问题&#xff0c;但即使是经验丰富的开发人员也仍然很棘手。 单例模式是常见的编程习惯。 但是&#xff0c;当与多个线程一起使用时&#xff0c;必须进行某种类型的同步&#xff0c;以免破坏代码。 Khangaonkar报告中的 JCG合作伙伴Manoj Khangaonkar在一篇…

国内有哪些好的刷题网站?

http://www.zhihu.com/question/25574458 Luau Lawrence&#xff0c;Data Mining 弱鸡 / PhDNTU 温梦强、石一帆、知乎用户 等人赞同 - Welcome To PKU JudgeOnline 北京大学的Online Judge。POJ上面的题目有点老了&#xff0c;但好处是做的人多&#xff0c;经典算法题多&…

IE版本判断

我们常常会在网页的HTML里面看到形如[if lte IE 9]……[endif]的代码&#xff0c;表示的是限定某些浏览器版本才能执行的语句&#xff0c;那么这些判断语句的规则是什么呢&#xff1f;请看下文&#xff1a; <!--[if !IE]><!--> 除IE外都可识别 <!--<![endif]…

Js 流程控制

流程控制 顺序、分支、循环 顺序结构 代码一行一行从上往下执行并解析 分支结构 if语句 switch语句 if语句 单分支 if(条件表达式){ //语句块 } 含义&#xff1a;当条件表达式为真的时候就执行里面的语句块 示例&#xff1a; 双分支&#xff1a; if(条件表达式){ //语句块1 }el…

习题6-3 使用函数输出指定范围内的完数 (20 分)

本题要求实现一个计算整数因子和的简单函数&#xff0c;并利用其实现另一个函数&#xff0c;输出两正整数m和n&#xff08;0<m≤n≤10000&#xff09;之间的所有完数。所谓完数就是该数恰好等于除自身外的因子之和。例如&#xff1a;6123&#xff0c;其中1、2、3为6的因子。…

速览Java 7 MethodHandle及其用法

由于Java的Reflection API&#xff0c;我们已经能够在运行时检查和更改程序执行。 特别是&#xff0c;我们可以在运行时观察接口/类/方法和字段&#xff0c;而在编译时不知道它们的名称。 JDK 7为这种动态/运行时检查引入了一个新的参与者&#xff0c;即方法句柄&#xff08;即…

习题6-4 使用函数输出指定范围内的Fibonacci数 (20 分)

本题要求实现一个计算Fibonacci数的简单函数&#xff0c;并利用其实现另一个函数&#xff0c;输出两正整数m和n&#xff08;0<m≤n≤10000&#xff09;之间的所有Fibonacci数。所谓Fibonacci数列就是满足任一项数字是前两项的和&#xff08;最开始两项均定义为1&#xff09;…

SmartGWT入门,提供出色的GWT界面

SmartGWT简介 我最近开始使用SmartGWT &#xff0c;它是一个基于GWT的框架&#xff0c;该框架为您的应用程序UI提供了一个全面的小部件库&#xff0c;并为服务器端的数据管理提供了帮助。 您可以在SmartGWT展示柜上查看其漂亮的功能。 我准备了一个简短的“入门”指南&#xf…

Android OpenGL ES(四)----调整屏幕的宽高比

1.宽高比问题 我们现在相当熟悉这样一个事实&#xff0c;在OpenGL里&#xff0c;我们要渲染的一切物体都要映射到X轴和Y轴上[-1&#xff0c;1]的范围内&#xff0c;对于Z轴也一样。这个范围内的坐标被称为归一化设备坐标&#xff0c;其独立于屏幕实际尺寸或形状。 不幸的是&…

使用Spring AOP进行面向方面的编程

面向方面的编程&#xff08;AOP&#xff09;是指将辅助功能或支持功能与主程序的业务逻辑隔离开来的编程范例。 AOP是用于分离横切关注点的有前途的技术&#xff0c;这在面向对象的编程中通常很难做到。 以此方式增加了应用程序的模块化&#xff0c;并且维护变得非常容易。 横切…

面试题24 二叉搜索树的后序遍历序列

题目描述 输入一个整数数组&#xff0c;判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。1 class Solution {2 public:3 bool VerifySquenceOfBST(vector<int> sequence) {4 if (seque…

习题6-5 使用函数验证哥德巴赫猜想 (20 分)

本题要求实现一个判断素数的简单函数&#xff0c;并利用该函数验证哥德巴赫猜想&#xff1a;任何一个不小于6的偶数均可表示为两个奇素数之和。素数就是只能被1和自身整除的正整数。注意&#xff1a;1不是素数&#xff0c;2是素数。 函数接口定义&#xff1a; int prime( int…

Linux学习笔记 (六)用户管理命令

一、用户帐号 1、超级用户&#xff1a;具有操作系统中的最高权限&#xff0c;用来管理和维护操作系统。root用户。 2、普通用户&#xff1a;由root用户来创建&#xff0c;在宿主目录中具有完全权限。 3、程序用户&#xff1a;由应用程序添加&#xff0c;维护某个应用程序运行。…

使用Spring Security保护GWT应用程序

在本教程中&#xff0c;我们将看到如何将GWT与Spring的安全模块&#xff08;即Spring Security&#xff09;集成在一起。 我们将看到如何保护GWT入口点&#xff0c;如何检索用户的凭据以及如何记录各种身份验证事件。 此外&#xff0c;我们将实现自定义身份验证提供程序&#x…

用Fragment制作的Tab页面产生的UI重叠问题

本文出处&#xff1a;http://blog.csdn.net/twilight041132/article/details/43812745 在用Fragment做Tab页面&#xff0c;发现有时候进入应用会同时显示多个Tab内容&#xff0c;UI发生重叠。 当应用被强行关闭后&#xff08;通过手机管家软件手动强关&#xff0c;或系统为节省…

习题6-6 使用函数输出一个整数的逆序数 (20 分)

本题要求实现一个求整数的逆序数的简单函数。 函数接口定义&#xff1a; int reverse( int number );其中函数reverse须返回用户传入的整型number的逆序数。 我的代码&#xff1a; int reverse( int number ) {int n number,res 0,t 0;n (n>0)?n:-n;while(n ! 0){t…

Tomcat 7上具有RESTeasy JAX-RS的RESTful Web服务-Eclipse和Maven项目

开发Web服务的RESTful方法不断受到越来越多的关注&#xff0c;并且似乎正在将SOAP淘汰。 我不会讨论哪种方法更好&#xff0c;但是我相信我们都同意REST更轻量级。 在本教程中&#xff0c;我将向您展示如何使用RESTeasy开发RESTful服务以及如何将它们部署在Tomcat服务器上。 在…