我正在研究真正了解内存分配在JVM中的工作原理.我正在编写一个应用程序,其中我将失去内存:堆空间异常.
我知道我可以将诸如Xms和Xmx之类的VM参数传递给JVM为正在运行的进程分配的堆空间.这是问题的一种可能的解决方案,或者我可以检查我的代码是否存在内存泄漏并解决问题.
我的问题是:
1)JVM如何为自己实际分配内存？这与操作系统如何将可用内存传递给JVM有何关系？或者更一般地说,任何进程的内存分配实际上如何工作？
2)虚拟内存如何发挥作用？假设您有一个具有32GB物理内存的系统,并且您将所有32GB分配给您的Java进程.假设您的进程实际上消耗了所有32GB的内存,我们如何强制使用虚拟内存而不是运行到OOM异常？
谢谢.
我目前正在通过以下方式在非GUI模式下运行JMeter:
"apache-jmeter/bin/jmeter -n -t $testPlan.jmx -l results.jtl"
测试完成后,results.jtl文件包含如下内容:
1379545163610,186,HTTP Request,403,Forbidden,Service 1-30,text,false,239,186
看来它正在使用默认配置来输出什么,但如果我只想看到每行的延迟而不是这个大的csv值怎么办？我知道当你在GUI模式下使用JMeter时,以及当你添加一个新的监听器,例如"查看表中的结果"时,你可以配置应该写入生成的jtl文件的内容,例如响应代码,延迟,线程名称,等等
但是,我只想要延迟数据.如何通过此命令行而不是通过GUI配置？
谢谢!
我在这里查看文档:http://doc.akka.io/docs/akka/2.3.3/java/dispatchers.html
我们以这样的方式使用Akka,我们为不同的actor提供了两个独立的调度程序(默认的fork-join执行程序).我们现在遇到一些性能问题,我们正在研究如何调整调度程序配置参数并查看它们如何影响应用程序的性能.
我查看了文档,但并不真正了解配置参数.例如,仅针对简单的默认值,fork-join-executor调度程序:
这些是什么以及如何配置它们以了解它们如何影响应用程序性能？
# Min number of threads to cap factor-based parallelism number to
parallelism-min = 2
# Parallelism (threads) ... ceil(available processors * factor)
parallelism-factor = 2.0
# Max number of threads to cap factor-based parallelism number to
parallelism-max = 10
谢谢!
我目前正在研究Akka(Java版)中的Fault Tolerance和Supervisor策略.
at ... http://doc.akka.io/docs/akka/2.3.2/java/fault-tolerance.html和http://doc.akka.io/docs/akka/2.3.2/general/ supervision.html#监督
几个问题:
1)当我们知道期望什么样的例外时,我们是否应该在演员中使用try/catch块？为什么或者为什么不？如果没有,我们是否应该依靠主管策略来有效处理孩子可能抛出的异常？
2)默认情况下,如果在父actor中没有显式配置管理程序,则默认情况下将重启任何抛出异常的子actor.如果整个系统中的所有演员都没有状态怎么办...我们真的应该重启吗？
3)如果由system.actorOf(...)创建的顶级actor会引发异常怎么办？你如何在演员系统之外提供监督策略？
4)让我们假设一个场景,其中演员A有一个儿童演员B.现在让我们说演员A要求演员B做一些工作.
有些代码可能如下所示:
Future<Object> future = Patterns.ask(child, message, timeout);
future.onComplete(new OnComplete<Object>() {
@Override
public void onComplete(Throwable failure, Object result) throws Throwable {
... handle here
}
现在......如果演员A以某种方式抛出异常会怎样.默认情况下,它由主管重新启动.问题是,onComplete"闭包"是否仍会在将来的某个时间执行,还是在重启时有效"消失"？
5)假设我有一个层次结构,如:A-> B-> C. 我们也假设我覆盖preRestart,这样我就不会阻止我的孩子.在A的预启动时,他调用getContext().actorOf(B),并在B的预启动中调用getContext().actorOf(C).如果A抛出异常,系统中是否会存在多个actor B和多个actor C？
谢谢!
我正在尝试将OneForOneStrategy粘贴到一个简单的Hello-Akka程序中,就像基于这个文档一样:http://doc.akka.io/docs/akka/2.3.2/java/fault-tolerance.html
private static SupervisorStrategy strategy = new OneForOneStrategy(10,
Duration.create("1 minute"),
new Function<Throwable, SupervisorStrategy.Directive>() {
@Override
public SupervisorStrategy.Directive apply(Throwable t) {
if (t instanceof ArithmeticException) {
return resume();
} else if (t instanceof NullPointerException) {
return restart();
} else if (t instanceof IllegalArgumentException) {
return stop();
} else {
return escalate();
}
}
}
);
@Override
public SupervisorStrategy supervisorStrategy() {
return strategy;
}
但是,resume/restart/stop/escalate方法调用不会立即编译.为什么不？
我正在玩Akka的远程和序列化设施,想要了解一些事情要开始.我在这里阅读了有关序列化的文档:
http://doc.akka.io/docs/akka/2.3.4/scala/serialization.html
根据文档,似乎只需在我的application.conf中提供这些内容即可:
akka.actor {
serializers {
java = "akka.serialization.JavaSerializer"
proto = "akka.remote.serialization.ProtobufSerializer"
}
serialization-bindings {
"com.mycompany.messages.MyMessage" = proto
}
}
我们假设我在该软件包下有一个案例类,例如:
package com.mycompany.messages;
case class MyMessage(name: String, year: Int)
然后在我的演员中,我可以简单地做这样的事情:
class ClientActor extends Actor {
def receive = {
case x: MyMessage => ...
}
}
这种配置是否足够,还是我需要做更多的事情？我看过这里的文档中提到的外部序列化程序:https: //github.com/romix/akka-protostuff-serialization
这看起来很有希望,但我正在寻找Akka开箱即用的标准.
我也在考虑测试消息版本的兼容性.假设Actor A使用MessageX与Actor B 对话
MessageX最初可能包含这样的字段:
a: String, b: String, c: String
现在让我们说Actor B升级它的Message X版本,让我们称之为Message X +1
消息X + 1 …
我正在配置我的Akka应用程序以使用此处指定的SLF4J记录器:
http://doc.akka.io/docs/akka/2.3.4/scala/logging.html
在引擎盖下,我依靠Logback进行日志记录.我正在开发一个用于日志记录目的的通用模块,用户可以在他们的actor系统中使用.主要是,我正在创造一个他们可以混合的特质.
我有一个特点,这样做:
我有这样的东西:
trait ActorLogger {
val log: DiagnosticLoggingAdapter = Logging(this);
}
我有一些额外的逻辑,它将MDC值添加到DiagnosticLoggingAdapter的MDC.现在的问题是:如果用户想要混合到非演员类,我会完全暴露一个不同的记录器.所以我可能有这样的事情:
trait ClassLogger {
val log = LoggerFactory getLogger getClass.getName
}
我希望MDC值能够延续到此记录器.因此,例如,如果我将MDC值放入我的DiagnosticAdapterLogger,我应该能够从org.slf4j.MDC获取这些值
如何以干净的方式实现这一目标？
谢谢!
我正在查看关于无类型演员的Akka Java文档(http://doc.akka.io/docs/akka/2.3.2/java/untyped-actors.html)
我有效地希望完成以下事情:
为我希望在onReceive()方法中接收的任何特定消息设置超时.例如:
public void onReceive(Object message) throws Exception {
if (message.equals("start")) {
child.tell("fetch something for me!", getSelf());
}
if (message.equals("child's response")) {
// handle a response from a child here,
// but timeout within some timeframe if I don't get a
// response quick enough.
// use this here? getContext().setReceiveTimeout(Duration.create("1 second"));
}
}
我知道你可以使用Patterns.ask(actor,message,timeout),它返回一个未来.如果未在指定的超时参数内发回响应,则失败.
我不想在这里使用期货.我不明白setReceiveTimeout方法的用法.我如何通过纯粹使用actor.tell来实现这一目标？
据我了解，onReceive只能在任何给定的时间点由一个线程执行。
假设我有一个无类型的actor定义如下：
import akka.actor.ActorRef;
import akka.actor.Props;
import akka.actor.UntypedActor;
public class ExampleActor extends UntypedActor {
private ActorRef databaseActor;
@Override
public void preStart() {
ActorRef databaseActor = getContext().system().actorOf(Props.create(DatabaseActor.class));
}
@Override
public void onReceive(Object message) throws Exception {
if (message.equals("start")) {
// spawn a child actor of myself!
ActorRef child = getContext().actorOf(Props.create(ExampleActor.class));
databaseActor.tell("fetch", child);
}
if (message.equals("dbresponse")) {
// just log the repsonse here!
}
if (message.equals("something else")) {
// possibly mutate state
}
}
}
我本质上是想使用Akka而不使用期货。同时，我希望我的演员不要尽可能多地阻止。是否可以在我的onReceive，soley中生成递归子角色以处理来自其他角色的特定消息？
本质上，在我的“ if（message.equals（“ dbresponse”））”中，我只想记录数据库响应，而不是在ExampleActor中更改状态。
这种方法行得通吗？像这样即时创建演员的后果是什么？
这是一个例子中的代码:
import spray.routing.SimpleRoutingApp
object Main extends App with SimpleRoutingApp {
implicit val system = ActorSystem("my-system")
startServer(interface = "localhost", port = 8080) {
path("hello") {
get {
complete {
<h1>Say hello to spray</h1>
}
}
}
}
}
发现于http://spray.io/documentation/1.1-SNAPSHOT/spray-routing/#spray-routing
请原谅我的高兴,因为我来自Java背景......我正在尝试同时获取Scala语言以及此框架.我在语义上理解这里发生了什么,但从语法上来说,我很困惑.
我想了解Scala语言中的哪些构造在这里应用,特别是从调用"startServer"开始,以及{}之间的实现.这样我可以谷歌并研究它...但我不知道该在这里查找什么.我认为这可能与该语言中的一些功能概念有关.
"startServer"似乎是SimpleRoutingApp的一种方法,但看起来你将嵌套函数传递到它的主体,即"路径","获取","完整"......这究竟是如何工作的？谢谢你的帮助.