小编pet*_*ter的帖子

我想知道在以下示例中有哪些替代方法可以避免死锁.以下示例是传输死锁问题的典型银行帐户.在实践中有哪些更好的解决方法？

class Account {
     double balance;
     int id;
     public Account(int id, double balance){
          this.balance = balance;
          this.id = id;
     }
     void withdraw(double amount){
          balance -= amount;
     } 
     void deposit(double amount){
          balance += amount;
     }
}
class Main{
     public static void main(String [] args){
           final Account a = new Account(1,1000);
           final Account b = new Account(2,300);
           Thread a = new Thread(){
                 public void run(){
                     transfer(a,b,200);
                 }
           };
           Thread b = new Thread(){
                 public void run(){
                     transfer(b,a,300);
                 }
           };
           a.start();
           b.start();
     } …

我想知道有一个嵌套的抽象类是什么意思？例如,

   abstract class A{

          abstract class B{

          }
   }

是否存在我们可能需要的用例或场景,例如设计？或者这种模式中有用的东西吗？为什么Java允许我们这样做？

据我所知,这java.util.Date是可变的,所以如果多个线程试图访问和修改它,它就不是线程安全的.我们如何使用客户端锁定或组合(包装器)使其线程安全？

我想知道ConcurrentHashMap如何处理rehashing而另一个线程仍然在另一个段/分区上写.据我所知,ConcurrentHashMap独立地锁定了段,因此,例如,Thread1在Thread2写入segment2之前稍微写入segment1,如果它要求表在Thread1插入后调整大小并重新散列,会发生什么,但是Thread2位于中间写作操作？它会锁定整个地图以进行重组吗？它是否有类似告诉Thread2停止并等到rehash完成？因为Thread2可能有机会在表调整大小后最终写出segment1,对吗？

从Effective Java Item 18,它建议我们可以通过提供抽象骨架实现类来组合接口和抽象类.我想知道我们何时应该使用骨架实现进行模拟多重继承？什么是优点和缺点？有人能举个例子吗？

我想知道如果我们在静态方法中声明它们,所有局部变量都会变为静态吗？

例如:

  public static void A(){
        int x [] = {3,2};
        changeX(x);

        for (int i = 0; i< x.length; i++){
             System.out.println(x[i]);   // this will print -1 and 1
        }
  }
  private static void changeX(int[] x){
        x[0] = -1;
        x[1] =  1;
  }

据我所知,Java总是按值传递,但是为什么在我们进行changeX调用后X的状态发生了变化？有人可以解释一下吗？任何人都可以解释Java如何在内存分配方面处理静态变量？如果我们将静态变量作为参数传递给函数会发生什么(我知道人们通常不这样做)

我在util.TreeSet类中发现其中一个构造函数正在使用new TreeMap泛型类型调用另一个构造函数.

  public TreeSet(Comparator<? super E> comparator) {
         this(new TreeMap<>(comparator));
  }

什么new TreeMap<>意思？那相当于new TreeMap<?>？

该toArray方法(可以接在执行java.util.ArrayList)如下:

class ArrayList<E> ....{
    public <T> T[] toArray(T[] a){
        if(a.length < size)
            return (T[]) Arrays.copyof(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if(a.length > size)
            a[size] = null;
        return a;
    }    
}

我想知道我们可以使用<E>而不是<T>在这种情况下吗？喜欢

public E[] toArray(E[] a){
      if(a.length < size)
             return (E[]) Arrays.copyof(elementData, size, a.getClass());
      System.arraycopy(elementData, 0, a, 0, size);
      if(a.length > size)
            a[size] = null;
      return a;
}    

由于ArrayList类iteself已经是通用的<E>,所以我们可以使用它而不是新的泛型类型<T>吗？

我注意到Java浮点精度的一些问题

       Float.parseFloat("0.0065") - 0.001  // 0.0055000000134110451
       new Float("0.027") - 0.001          // 0.02600000000700354575
       Float.valueOf("0.074") - 0.001      // 0.07399999999999999999

我不仅有问题,Float而且还有问题Double.

有人可以解释幕后发生的事情,我们怎样才能获得准确的数字？在处理这些问题时,处理此问题的正确方法是什么？

我想知道使用空块的目的是什么.例如,

    static{
        int x = 5;
    }

    public static void main (String [] args){

          int i = 10;

          {
               int j = 0 ;
               System.out.println(x);  // compiler error : can't find x ?? why ??
               System.out.println(i);  // this is fine
          }
          System.out.println(j); //compiler error :  can't find j

    }

有人可以解释

1. 在什么情况下我们想要使用空块.
2. 该空块内的所有变量是否仍然存在stack？
3. 为什么不能访问static variable x？