小编pet*_*ter的帖子

我想知道在多线程环境中实践中哪个更好。我将 Singleton 理解为 Enum 类型在加载类时创建一个实例。除此之外，我没有看到任何其他重要的东西。有什么优点和缺点吗？

单例Enum类型：

 public enum Singleton {
      INSTANCE;
      public void doSomething(){ ... }
 }

单身人士double-checked locking：

 public class Singleton{
      private volatile static Singleton instance;

      private Singleton(){}
      public static Singleton getInstance(){
           if(instance == null){
                 synchronized(Singleton.class){
                       if(instance == null){
                           instance = new Singleton();
                       }
                 }
           }
           return instance;
      }

 }

如果我们想要实现资源池,例如数据库连接池.您将使用哪个并发集合？BlockingQueue还是Semaphore？

因为BlockingQueue,就像生产者 - 消费者设计模式一样,生产者将所有连接放在队列上,而消费者将从队列中获取下一个可用连接.

对于Semaphore,您将信号量指定为池大小,并获取许可,直到达到池大小并等待其中任何一个释放许可并将资源放回池中.

哪一个更简单,更容易？什么是我们只能使用一个而不是其他的情况？

我想知道如果在方法中声明一个本地线程会发生什么？通常,函数返回后,所有局部变量都将消失,因为它们都在Stack上分配.然而,似乎本地线程将是一个不同的故事.是对的吗？

public int A() {
    Thread t = new Thread() {
        doSomething();
    }
    t.start();
    return -1;
 }

我正在读" Java Concurrency in Practice "一书,它说,

CyclicBarrier 允许固定数量的方在障碍点重复会合,并且在将问题分解为固定数量的独立子问题的并行迭代算法中是有用的.

有人能举例说明它如何将问题分解为多个独立的子问题吗？

任何人都可以解释为什么以下递归方法比迭代方法更快(两者都在进行字符串连接)？是不是迭代的方法想要打败递归的？加上每个递归调用在堆栈顶部添加一个新层,这可能是非常低效的空间.

    private static void string_concat(StringBuilder sb, int count){
        if(count >= 9999) return;
        string_concat(sb.append(count), count+1);
    }
    public static void main(String [] arg){

        long s = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < 9999; i++){
            sb.append(i);
        }
        System.out.println(System.currentTimeMillis()-s);
        s = System.currentTimeMillis();
        string_concat(new StringBuilder(),0);
        System.out.println(System.currentTimeMillis()-s);

    }

我多次运行该程序,递归的程序总是比迭代程序快3-4倍.可能导致迭代速度变慢的主要原因是什么？

我想知道你能指定一个变量来提醒吗？这到底意味着什么？例如,

var a = alert('test');  

我试了一下,一旦页面加载,当我调用它时变量a仍然存在'undefined'时,警报会弹出.我们不是想把它变成一个匿名函数,里面有警报

var a = function(){ alert('test'); }

如果我们想要触发某事的警报？为什么javascript允许你这样做？

我想知道Java HashMap当负载系数超过阈值时,调整大小的时间复杂度是多少？据我所知,HashMap的表大小始终是2的偶数,所以每当我们调整表的大小时,我们都不需要重新调整所有键(如果我错了就纠正我),我们需要做的就是是没有分配额外的空格并复制旧表中的所有条目(我不太确定JVM如何在内部处理它),对吗？而对于Hashtable因为它使用一个素数作为表的大小,所以我们需要所有的老调重弹,每当我们重新大小的条目表.所以我的问题是它还需要O(n)线性时间来调整大小HashMap吗？

我想知道幂集问题能否转化为背包问题？在我看来，它们是相同的，例如，我们可以将其视为幂集，即每个递归阶段都会启动 2 个递归调用（一个采用 thi元素，另一个绕过它）。我也可以像背包问题一样用动态规划来解决它，所以这让我想知道是否所有幂集问题都可以转化为背包问题。那是对的吗 ？

以下是硬币变化的代码片段，其中一个具有 O(2 ^N ) 时间复杂度，另一个具有 O(N ² ) 运行时间的动态编程。

// O(2^N) time complexity
void bruteforce(int[] coins, int i, int N, String expr) 
{
     if (i == coins.length) {
         if (N == 0)
            count++;
         return;
     }

     if (N >= coins[i])
         recursion(coins, i, N - coins[i], expr + " " + coins[i]);
     recursion(coins, i + 1, N, expr);
}

// O(N^2) time complexity
int dynamicProgramming(int[] coins, int N) 
{
     int [] dp = new int[N …

关于volatile变量如何从"主"内存有效访问,我有点困惑.它与具有本地副本的变量(非易失性)有什么不同？什么是每当多个线程访问非易失性的典型工作流程VS volatile变量？我的意思是他们如何在幕后工作？

当我们谈论构造线程安全类时，我并没有真正理解“委托”的概念。这是什么意思？以及该策略如何有效地创建线程安全类？何时会失败？有人可以举个例子吗？