小编byl*_*nan的帖子

我想在整个应用程序中使用相同的线程池.为此,我可以让ExecutorService静态和全局,这样我可以调用ThreadUtil.executorService得到ExecutorService,当我需要它.

public class ThreadUtil {
    public static final ExecutorService executorService = Executors.newCachedThreadPool();
}

可以像这样实例化多个线程池吗？

另外,我的应用程序是TCP服务器.如果我不知道游泳池应该有多大,可以简单地使用newCachedThreadPool吗？

我tcp-backlog在redis.conf中感到困惑:

# TCP listen() backlog.
#
# In high requests-per-second environments you need an high backlog in order
# to avoid slow clients connections issues. Note that the Linux kernel
# will silently truncate it to the value of /proc/sys/net/core/somaxconn so
# make sure to raise both the value of somaxconn and tcp_max_syn_backlog
# in order to get the desired effect.
tcp-backlog 511

是tcp-backlog"完整连接队列"的大小(三次握手完成,这里描述的是什么)还是"不完整的连接队列"？

如果它意味着"完整的连接队列"那么我为什么要提出tcp_max_syn_backlog哪个限制了一个不完整的连接队列的大小？

我有这样的服务:

class DemoService {
    Result process(Input in) {
        filter1(in);
        if (filter2(in)) return...
        filter3(in);
        filter4(in);
        filter5(in);
        return ...

    }
}

现在我想要它更快,我发现一些过滤器可以同时启动,而一些过滤器必须等待其他过滤器完成.例如:

filter1--
         |---filter3--
filter2--             |---filter5
          ---filter4--

意思是:

1.filter1和filter2可以同时启动,filter3和filter4也是如此

2.filter3和filter4必须等待filter2完成

还有一件事:

如果filter2返回true,则'process'方法立即返回并忽略以下过滤器.

现在我的解决方案是使用FutureTask:

            // do filter's work at FutureTask
        for (Filter filter : filters) {
            FutureTask<RiskResult> futureTask = new FutureTask<RiskResult>(new CallableFilter(filter, context));
            executorService.execute(futureTask);
        }

        //when all FutureTask are submitted, wait for result
        for(Filter filter : filters) {
            if (filter.isReturnNeeded()) {
                FutureTask<RiskResult> futureTask = context.getTask(filter.getId());
                riskResult = futureTask.get();
                if (canReturn(filter, riskResult)) { …

我谷歌了一下，找到了两个解决方案：

1. CLUSTER FORGET( http://redis.io/commands/cluster-forget )

2. redis-trib.rb del-node

我认为CLUSTER FORGET“是正确的做法。

但我真的很想知道有关redis-trib.rb del-node.

有人可以解释它们之间的区别吗？

我正在使用 redis 集群 3.0.1。

我认为 redis 集群使用一致的哈希。哈希槽类似于一致性哈希中的虚拟节点。Cassandra的数据分布和redis cluster差不多，本文说的是consistent hashing。

但是redis cluster turorial说redis cluster没有使用一致的hash。

我想念什么？谢谢。

使用java：

File file = new File("C:/Users/Administrator/Desktop/es.txt");
    List<String> lines = FileUtils.readLines(file, "utf-8");
    for (String line : lines) {
        String[] arr = line.split("\\u007C\\u001C");
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));
    }

我如何在 shell（awk、tr 或 sed）中执行此操作？我已经尝试过这个，但它不起作用：

awk -F\u007c\u001c '{print $1}' es.txt

谢谢。

我想是的，但我不太确定。例如：

class Person {
    int age;
    int salary;
    int bonus;
    //getter and setter

    public int calcIncome () {
        return salary + bonus;
    }
}

博士升：

when 
    $p:Person(age > 30, calcIncome() > 1000)
then
        ...

它是否等于：

    if (person.getAge() > 30 && person.calcIncome() > 1000) {
    ...
    }

那么当人的年龄不大于30岁时，calcIncome方法将不会被评估？

谢谢！

我想实现一个简单的循环负载平衡器，并且我想要“getServer”方法线程安全：

private static int[] servers = new int[]{0,1,2};


private static int SERVER_INDEX = 0;

//not fast enough?
public synchronized static int getServer() {
    SERVER_INDEX++;
    if (SERVER_INDEX >= servers.length - 1) {
        SERVER_INDEX = 0;
    }
    return servers[SERVER_INDEX];
}


private static AtomicInteger SERVER_INDEX_2 = new AtomicInteger(0);

//not thread-safe and will get Exception
public static int getServer2() {
    int index = SERVER_INDEX_2.getAndIncrement();
    if (index >= servers.length - 1) {
        SERVER_INDEX_2.set(0);
    }
    return servers[index]; //ERROR! arrayIndexOutOfRange
}



private static AtomicLong SERVER_INDEX_3 = new …