小编MrR*_*ROY的帖子

我已经阅读了博客,但我不确定他的结论是否正确:

http://www.javacodegeeks.com/2010/09/java-best-practices-queue-battle-and.html#ixzz1seaiSLwp

他说:从提供的性能结果可以看出,LinkedBlockingQueue实现了最佳的组合(添加和删除元素)性能结果,应该是实现生产者 - 消费者schenarios的头号候选者.

我想知道,如果我不在我的代码中使用锁定,那么它会不会更快？

那么为什么LinkedBlockingQueue比无锁队列(ConcurrentLinkedQueue)更快？

谢谢 !

我想知道通道是否足够有效,可以用作编写Go程序的一部分.

我正在尝试实施一个字数统计程序,但第一步我遇到了一些问题.

这是我的代码:

package main

import (
    "fmt"
    "os"
    "bufio"
    "sync"
)

// Load data into channel
func laodData(arr []string,channel chan string,wg sync.WaitGroup) {
    for _,path := range arr {
        file,err := os.Open(path)
        fmt.Println("begin to laodData ", path)
        if err != nil {
            fmt.Println(err)
            os.Exit(-1)
        }
        defer file.Close()
        reader := bufio.NewReaderSize(file, 32*10*1024)
        i := 0
        for {
            line,err := reader.ReadString('\n')
            channel <- line
            if err != nil {
                break
            }
            i++
            if i%200 == 0 {
                fmt.Println(i," lines parsed")
            }
        } …

我正在阅读Andrew NG的机器学习笔记,但功能边缘定义让我困惑:

我可以理解几何边距是从x到超平面的距离,但是如何理解功能边界？为什么他们这样定义公式？

我现在正在玩游戏,这里是controller.class中的一些代码,我不明白:

/**
 * Render a 200 OK application/json response
 * @param jsonString The JSON string
 */
protected static void renderJSON(String jsonString) {
    throw new RenderJson(jsonString);
}

有没有什么重要的原因让play框架简单地抛出一个新的Render对象？似乎有线使用"抛出"而没有例外.

想想这段代码:

#!/usr/bin/env python

from threading import Thread

count = 0

def test():
    global count
    for i in range(10):
        count = count + 1

if __name__ == '__main__':
    for i in range(1000):
        Thread(target = test).start()
    print count

我使用多个线程,但结果总是正确的.这是否意味着我可以在实现像访问者计数器之类的东西时使用没有锁定的python线程？

我的HTML代码如下所示:

<div class="ctn">
    <img src="some-img.jpg"/>
</div>

它ctn应该是固定的尺寸,比如150*150.

但IMG的大小可能更大或更小:200*50,50*200,50*50等.

如何使图像适合中心div？不应更改图像的比例.

====更新====是的,我需要hori和垂直中心.

我的浏览器中有一个3D球，现在我想在其上挖一个洞以查看其背面。

我如何使其成为可能？

例如，我希望立方体的白色三角形部分可以是透明的（我的意思是我们可以看到立方体后面的背景）。

我试图在片段着色器中更改Alpha（代码中的区域是正方形而不是三角形，没关系）：

<script id="shader-fs-alpha" type="x-shader/x-fragment">
    precision mediump float;

    varying vec4 vColor;

    uniform float uAlpha;

    void main(void) {
      if( gl_FragCoord.x < 350.0 && gl_FragCoord.x > 300.0
        && gl_FragCoord.y < 300.0 && gl_FragCoord.y > 230.0
        ) {
        gl_FragColor = vec4(0, 0 ,0, 0.0);
      } else {
        gl_FragColor = vec4(vColor.rgb, 1.0);
      }
    }
</script>

这实际上有效，但是该区域变为白色（不透明），因此我尝试启用混合，但这使整个立方体透明。

所以现在我想如果有一种bleanding在片段着色器中启用的方法，可以在else块中禁用它。

这是我的整个项目https://gist.github.com/royguo/5873503：

• index.html：此处的着色器脚本。
• buffers.js：这里的所有对象。
• shaders.js：初始化着色器。

我已经安装了Numpy和SciPy,但我不太了解他们的文档polyfit.

对于exmpale,这是我的三个数据样本:

[-0.042780748663101636, -0.0040771571786609945, -0.00506567946276074]
[0.042780748663101636, -0.0044771571786609945, -0.10506567946276074]
[0.542780748663101636, -0.005771571786609945, 0.30506567946276074]
[-0.342780748663101636, -0.0304077157178660995, 0.90506567946276074]

前两列是样本特征,第三列是输出,我的目标是获得一个可以采用两个参数(前两列)并返回其预测(输出)的函数.

任何简单的例子？

======================编辑======================

请注意,我需要适合的东西curve,不仅仅是直线.多项式应该是这样的(n = 3):

a*x1^3 + b*x2^2 + c*x3 + d = y

不:

a*x1 + b*x2 + c*x3 + d = y

x1,x2,x3是一个样本的特征,y是输出

原始数据如下所示:

String data = "{ \"a\":1, \"b\":3 , \"c\":-1 }";

我的第一步是将其转换为HashMap:

Gson gson = new Gson();
HashMap<String, Double> map = gson.fromJson(data, HashMap.class);

然后按键值对键进行排序:

public static List<String> sortHashMap(final HashMap<String, Double> map) {
    Set<String> set = map.keySet();
    List<String> keys = new ArrayList<String>(set);

    Collections.sort(keys, new Comparator<String>() {

        @Override
        public int compare(String s1, String s2) {
            if (map.get(s1) < map.get(s2)) {
                return 1;
            }
            return 0;
        }
    });

    return keys;
}

最后,获得前N键:

keys.subList(0, N);

我终于得到了结果,但我不认为这是一种优雅的方式.

所以我想知道,有没有方便的方法来制作它？