小编sky*_*yde的帖子

在像python和ruby这样的语言中,要求语言它的字符串类支持哪些与索引相关的方法(哪些方法的名称包含单词"index"),你可以做

“”.methods.sort.grep /index/i

而在java中

List results = new ArrayList();  
Method[] methods = String.class.getMethods();  
for (int i = 0; i < methods.length; i++) {  
    Method m = methods[i];  
    if (m.getName().toLowerCase().indexOf(“index”) != -1) {  
        results.add(m.getName());  
    }  
}  
String[] names = (String[]) results.toArray();  
Arrays.sort(names);  
return names;  

你会如何在Scala中做同样的事情？

在运行中调用runtime.GOMAXPROCS(1)时,运行时只会为所有goroutine使用一个线程.当你做你的goroutines会产生并让其他goroutines在同一个线程上运行.

对于我来说,如果你不使用后台线程,.net异步CTP功能如何进行协同并发似乎非常相似.

我的问题是你能想到一种方法优于另一种方法的优点或缺点.

我需要实现前缀和算法,并且需要它尽可能快.例如:

[3, 1,  7,  0,  4,  1,  6,  3]

有没有办法使用SSE/mmx/SIMD cpu指令执行此操作？

我的第一个想法是递归并行地对每一对求和,直到所有的总和都计算如下!

[3, 4, 11, 11, 15, 16, 22, 25]

为了使算法更清晰,"z"不是最终的输出

而是用来计算输出

//in parallel do 
for (int i = 0; i < z.length; i++) {
    z[i] = x[i << 1] + x[(i << 1) + 1];
}

是否可以使用Apache mahout而不依赖于Hadoop.

我想在单个计算机上使用mahout算法,只在我的Java项目中包含mahout库,但我根本不想使用hadoop,因为无论如何我将在单个节点上运行.

那可能吗？

从我的承诺来看,不可能完全阻止交易陷入僵局.

我希望从应用程序代码的角度来看,交易永远不会失败.所以我已经看到这个模式用于Microsoft SQL,我想知道这是一个好主意吗？

    DECLARE @retry  tinyint
    SET @retry  = 5
    WHILE @retry >0
    BEGIN
      BEGIN TRANSACTION
      BEGIN TRY
        // do transaction her
        COMMIT
        BREAK
      END TRY
      BEGIN CATCH
        ROLLBACK

        if (ERROR_NUMBER() = 1205 OR ERROR_NUMBER() = 1222)
        BEGIN
          SET @retry = @retry - 1
          IF @retry = 0
             RAISEERROR('Could not complete transaction',16,1);
          WAITFOR DELAY '00:00:00.05' -- Wait for 50 ms
          CONTINUE
        END
        ELSE
        BEGIN
          RAISEERROR('Non-deadlock condition encountered',16,1);
          BREAK;
        END
      END CATCH;
    END

有没有相当于Haskell Control.Parallel.Strategies或实现相同的方法？

这允许以不同的方式评估现有代码.通过将算法与策略和算法从评估中分离出来.

我在GO中重写一个旧系统,在旧系统中我测量系统负载平均值,以了解我是否应该增加线程池中的线程数.

在go中,人们不使用线程池或goroutine池,因为启动goroutine非常便宜.但仍然运行太多goroutine效率低,只是足以使cpu使用率接近100%

因此,有没有办法知道有多少goroutine准备运行(未阻止)但当前没有运行.或者有没有办法获得计划的runnable goroutine"运行队列"的数量.

我的理解是 IPFS 和 Bittorrent Mainline DHT 建立在分布式哈希表 (Kademlia) 之上。他们使用文件哈希作为 Kademlia 密钥来查找可能拥有此文件的对等点列表。

1- 我不明白的是，这是否都是分散的，谁从不再托管文件内容的 DHT 对等方中删除？

2- 什么阻止某人在 DHT 中免费存储大量数据？

3- 什么防止某人通过为流行文件添加大量无效对等点来破坏网络。

4- 什么阻止坏人加入 DHT 环而不遵循路由协议，从而阻止发现消息到达正确的节点。

我正在使用Hornetq 2.0我不知道我怎么知道目前有多少消息在队列中.

这是一个非常有用的功能,所以我可以在运行时知道我的消费者是否足够快地消费消息.

我没有使用JMS api,而是使用高度优化的核心API.

获取队列中消息数的正确(最快)方法是什么？

我找到了2路,但不知道这是什么方法.

public int size(){

    ClientSession session;

    try {

        session = sf.createSession(false, false, false);

        ClientRequestor requestor = new ClientRequestor(session, "hornetq.management");

        ClientMessage m = session.createMessage(false);

        ManagementHelper.putAttribute(m, "core.queue." + queueName, "messageCount");

        ClientMessage reply = requestor.request(m);

        int count = (Integer) ManagementHelper.getResult(reply);

        return count;

    } catch (Exception e) {

        e.printStackTrace();

    }

    return 0;

}

要么

public synchronized int size(){

    ClientSession coreSession = null;

    int count = 0;

    try {

        coreSession = sf.createSession(false, false, false);

        ClientSession.QueueQuery result;

        result = coreSession.queueQuery(new …

F#Computation Expressions允许隐藏厚层语法糖背后的一元语法的复杂性.Scala中是否有类似的东西？

我认为这是为了理解......

例:

val f = for {
  a <- Future(10 / 2) // 10 / 2 = 5
  b <- Future(a + 1)  //  5 + 1 = 6
  c <- Future(a - 1)  //  5 - 1 = 4
 } yield b * c         //  6 * 4 = 24

 val result = f.get

但它确实感觉不对.有更好的语法吗？

例如,你可以拥有哈斯克尔

    main = do fromHandle <- getAndOpenFile "Copy from: " ReadMode
          toHandle   <- getAndOpenFile "Copy to: " WriteMode 
          contents   <- hGetContents fromHandle …