小编Eug*_*Loy的帖子

我正在玩Java 8的流,无法理解我得到的性能结果.我有2个核心CPU(Intel i73520M),Windows 8 x64和64位Java 8更新5.我正在做简单的字符串流/并行流Strings,发现并行版本有点慢.

Function<Stream<String>, Long> timeOperation = (Stream<String> stream) -> {
  long time1 = System.nanoTime();
  final List<String> list = 
     stream
       .map(String::toLowerCase)
       .collect(Collectors.toList());
  long time2 = System.nanoTime();
  return time2 - time1;
};

Consumer<Stream<String>> printTime = stream ->
  System.out.println(timeOperation.apply(stream) / 1000000f);

String[] array = new String[1000000];
Arrays.fill(array, "AbabagalamagA");

printTime.accept(Arrays.stream(array));            // prints around 600
printTime.accept(Arrays.stream(array).parallel()); // prints around 900

考虑到我有2个CPU内核的事实,并行版本不应该更快吗？有人能给我一个暗示为什么并行版本更慢？

我尝试使用Qt(4.6.3)+ MinGW编译以下代码:

#include <QtCore/QCoreApplication>
#include <exception>

int main(int argc, char *argv[])
{
    throw std::runtime_error("");

    QCoreApplication a(argc, argv);

    return a.exec();
}

......并得到了这个错误:

..\untitled11\main.cpp:6: error: 'runtime_error' is not a member of 'std'

项目从头创建(控制台应用程序),专业文件:

QT       += core

QT       -= gui

TARGET = untitled11
CONFIG   += console
CONFIG   -= app_bundle

TEMPLATE = app

SOURCES += main.cpp

试图用Qt + MSVC2008编译器编译这个 - 工作正常.

这是标准的例外,不知道为什么会丢失.

好吧,我有点不好意思问这么简单但仍然.

我有命令行实用程序应用程序,需要向用户显示进度.

我可以将进度写入cout,如下所示:

std::cout << "10%\n";
...
std::cout << "20%\n";
...
std::cout << "30%\n";

...但结果用户会看到:

some line printed before
10%
20%
30%
...

...但我真正需要的是百分比得到更新,如下所示:

some line printed before
10%
...

......并在更新后:

some line printed before
20%
...

...并在第二次更新后:

some line printed before
30%
...

我该怎么做？

我的目标是允许在gdb中漂亮地打印Qt类.即如果我有:

QString str("str"); 

在我的代码中执行

(gdb) print qwe 

我想要打印str内容(不是真正的QString结构).

gdb本身支持使用python定义的漂亮打印机,似乎Qt Creator部分使用此功能.

理想的解决方案是使用Qt附带的漂亮打印机(可以在QT_INSTALLATION\share\qtcreator\gdbmacros中找到),甚至可以使用整个调试器(可以在QT_INSTALLATION\pythongdb中找到).

无论如何,巨魔建立了一个新的API来定义漂亮的打印机而不是标准的gdb api,我无法弄清楚如何在普通的gdb调试器中启用它.

那么,有没有办法在没有Qt Creator的情况下使用Qt的漂亮打印机运行gdb,或者有关如何管理它的任何信息.

让一个演员在失败时再次尝试一些东西的好方法是什么,但重试之间的时间间隔越来越长？假设我希望演员在15秒后再尝试30秒,然后每分钟再尝试一次.

这是我想出的:

• 执行实际工作的actor的方法有一个可选 RetryInfo参数,如果存在,则包含我们当前所在的重试次数
• 失败时,actor会自己发送一个新ScheduleRetryMessage的retryCount + 1,然后抛出一个RuntimeException
• 另一个演员监督工人演员,使用new OneForOneStrategy(-1, Duration.Inf()返回Resume作为其指令.演员没有状态,所以Resume应该没问题
• 在收到ScheduleRetryMessage,演员将
  • if retryCount < MAX_RETRIES:使用Akka的调度程序安排RetryMessage在所需的延迟之后发送
  • 否则:最后放弃,向另一个演员发送消息以进行错误报告

这是一个很好的解决方案还是有更好的方法？

我@SessionAttributes在春天使用,但我不知道如何结束会话,我尝试了下面的代码,但我收到错误,请给我一些例子.

谢谢.

@RequestMapping(value ="/LogoutAction")  
public String logout(HttpServletRequest request)    
{    
System.out.println("inside controller");    
     Resource res = new ClassPathResource("spring-context.xml");  
     BeanFactory factory = new XmlBeanFactory(res);  
     HttpSession session = request.getSession();  
     session.invalidate();  
return "Login";  
}

我是Akka的新手,也是分布式编程的新手.使用Akka的Mist组件,我创建了受监督的actor来异步处理HTTP请求.目前一切都在当地演员的一台物理机器上运行.我不明白的是如何构建一个具有多个盒子的真正容错系统.正如Akka文档中所述:

此外,您(通常)需要知道一个盒子是否关闭和/或您在另一个盒子上与之通话的服务是否已关闭.这里的actor监督/链接是一个关键工具,不仅可以监视远程服务的健康状况,还可以实际管理服务,如果actor或节点出现故障,可以对问题采取一些措施.例如在同一节点或另一个节点上重新启动actor.

我该怎么做呢？我正在寻找一个关于如何开始分发应用程序的示例或指针.我们组中的其他服务在多个Tomcat实例之前使用Apache网关,因此Tomcat服务器关闭的事件对用户是透明的.我正在将我的服务部署到Akka微内核,并且需要在多个物理盒中实现类似级别的高可用性.

我正在使用Akka 1.1.3.

我该如何处理DbActor抛出的异常？我不确定如何处理它,应该管道故障情况？

class RestActor extends Actor with ActorLogging {
  import context.dispatcher

  val dbActor = context.actorOf(Props[DbActor])
  implicit val timeout = Timeout(10 seconds)


  override val supervisorStrategy: SupervisorStrategy = {
    OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 10 seconds) {
      case x: Exception => ???
    }
  }

  def receive = {
    case GetRequest(reqCtx, id) => {

        // perform db ask
       ask(dbActor, ReadCommand(reqCtx, id)).mapTo[SomeObject] onComplete {
        case Success(obj) => { // some stuff }
        case Failure(err) => err match {
          case x: Exception => ???
        }
      } …

我正在和Akka一起玩,我有一个设计,其中一个主管演员有一个孩子扮演角色A和几个孩子扮演角色B.我想定义一个监督政策,如A失败升级(终止主管)和B生成要重新启动的各个actor.

这可能吗？这是可取的吗？

我目前正在研究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？

谢谢!