小编Jap*_* D.的帖子

我们的前端是简单的Jetty(稍后可能会被Tomcat替换)服务器.通过servlet,我们提供了一个公共HTTP API(或多或少RESTful)来公开我们的产品功能.

在后端,我们有一个Java进程,它可以执行多种维护任务.虽然后端进程通常会在有时间的情况下执行自己的任务,但是前端需要唤醒后端以在后台执行某项任务.

哪个(N)IO库是这项任务的理想选择？我找到了Netty,Grizzly,kryonet和普通的RMI.现在,我倾向于说Netty,它似乎很简单,它可能非常可靠.

你们有没有这种设置的经验？你会选择什么？

谢谢!

方法ConcurrentHashMap.putAll(Map)应该是原子的吗？

我在文档中找不到它,并且在ConcurrentMap界面中没有提到它,所以我猜答案是否定的.我要求它确定,因为如果该操作不是原子的,那就没有意义了.

如果它不是原子的,那么支持多个项目的原子插入的最佳方法是什么？回到好老同步？

我编写了一个Java应用程序,应该在数据库中发生"某事"时启动或唤醒.例如,插入用户表应该触发通常的欢迎,密码,...邮件的发送.

这样做的最常见做法是什么？我可以编写我的应用程序,以便它执行以下查询,让我们说每一秒:

select mail from user where mail_sent = false

但这是民意调查,我想避免它.有没有办法启动或唤醒由数据库更改启动的Java应用程序(推送)？

干杯!

说A是一个界面.有什么区别

public <T extends A> void foo(T t) { ... }

和

public void foo(A a) { ...}

？

我有一个简单的类,它在自己的线程中进行一些计算,并将结果报告给监听器.

class Calculator extends Thread {
    protected Listener listener;

    public void setListener(Listener l) {
        listener = l;
    }

    public void run() {
        while (running) {
            ... do something ...

            Listener l = listener;

            if (l != null) {
                l.onEvent(...);
            }
        }
    }
}

在任何时候,如果用户在一段时间内不想要任何事件,则可以调用setListener(null).因此,在run()函数中,我创建了一个侦听器的副本,因此我不能遇到NullPointerException,如果在!= null条件检查成功后将侦听器设置为null,则可能会发生这种情况.就我而言,我相信这是同步它的正确选择.

我的问题是:我应该在这里声明监听器成员变量为volatile吗？我已经阅读了很多关于volatile的内容,但是所有的例子似乎都是针对基本数据类型(boolean,int,...),而不是Objects.因此,我不确定对象是否应该/可以被声明为volatile.我相信我必须声明它是volatile,所以线程总是有成员变量的最新版本,但我不确定.

谢谢!

默认情况下,参数语句treshold设置为5,而不是1.也就是说,

((PGStatement) my_statement).getPrepareThreshold()

默认情况下始终返回5.

这是什么原因？为什么我不想在执行查询的前4次使用服务器端预处理语句？我无法理解为什么我会将其设置为另一个值而不是1,以及为什么默认设置为1.

你可以解释吗？非常感谢.

我想创建一个映射,从(a)类类型到(b)long(定义类类型的对象的标识符)到(c)对象本身.

我有以下内容:

 protected HashMap<Class<?>, HashMap<Long, ?>> obj = new HashMap<Class<?>, HashMap<Long, ?>>();

有可能以某种方式表示第一个?必须与第二个类型相同?吗？我希望这样的事情,但这是不可能的:

protected <T> HashMap<Class<T>, HashMap<Long, T>> obj = new HashMap<Class<T>, HashMap<Long, T>>();

我总是非常犹豫要把我的锁公开,让它们公开.我总是试图将锁限制在我的实现中.我相信,不这样做是一个僵局的秘诀.

我有以下课程:

class SomeClass {
    protected ArrayList<Listener> mListeners = new ArrayList<Listener>();

    protected void addListener(Listener listener) {
        synchronized (mListeners) {
            mListeners.add(listener);
        }
    }

    protected void removeListener(Listener listener) {
        synchronized (mListeners) {
            mListeners.remove(listener);
        }
    }

    ...
}

当SomeClass想要通知他的听众时,你会这样做:

    synchronized (mListeners) {
        for (Listener l : mListeners) {
             l.event();
        }
    }

要么

    Listener[] listeners = null;

    synchronized (mListeners) {
        listeners = mListeners.toArray();
    }
    for (Listener l : listeners) {
        l.event();
    }

我会选择第二种选择.缺点是听众可以获得活动,即使他们已经取消注册.好处是,一个侦听器calllback正在等待的线程,当他想取消注册一个监听器时,它不会遇到死锁.我认为好处比下行更重要,可以很容易地记录下来.

所以这里的问题基本上是:你会暴露你的锁吗？

我的问题不是你选择一个简单的ArrayList,LinkedList,ConcurrentLinkedQueue,CopyOnWriteArrayList,......!您是否会介意监听器是否可以在未注册时收到通知.无论你是否将锁打开,或不是.这是关于避免死锁.

请分享你的想法.谢谢!

我对通道管道的上游/下游处理程序中的并发性有疑问.我一直认为,如果在构造管道时创建了一个新的处理程序(也就是说,处理程序不在管道之间共享),最多只有一个线程与处理程序交互.

现在,我正在浏览这些例子.更具体地说,请看一下:http://docs.jboss.org/netty/3.2/xref/org/jboss/netty/example/discard/DiscardServerHandler.html

在代码中,有一个成员变量(它用于计算总字节数):

private final AtomicLong transferredBytes = new AtomicLong();

他们为什么在这里使用AtomicLong？处理程序的构造如下(请参阅http://docs.jboss.org/netty/3.2/xref/org/jboss/netty/example/discard/DiscardServer.html):

bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
    public ChannelPipeline getPipeline() throws Exception {
        return Channels.pipeline(new DiscardServerHandler());
    }
 });

因此,处理程序不会共享.我找不到他们想要在这里使用AtomicLong而不是简单长的原因.有人可以解释一下吗？

谢谢!