静态变量，线程和构造函数Java

Question

我从一本公认的示例书中看到了这一点，所以很难回答，然后有些我不明白的地方。

称为DataflightsService类包含名为FlightFileAccess一个私有静态变量出现每次我们创建DataflightsService一个新的对象FlightFileAccess的构造函数

即

public class DataflightsService{ 
    private static FlightFileAccess fileAccess=null; 

    public DataflightsService(String path){ 
     fileAccess=new flightFileAccess(path); 
    } 

    public boolean removeflight(String code){ 
     //We use this static instance that wraps functionality to remove a flight 
     fileAccess.remove(code); 
    } 
} 

开始其被实例化

---

对我来说，这意味着我们每次创建的实例10，在构造函数中使用的是不同的对象所有的时间静态变量FlightFileAccess

在原有FlightFileAccess类：我们有一个同步的RandomAccessFile

Class FlightFileAccess{ 
    private RandomAccessFile database = null; 
    private boolean remove(String code){ 
     // Other code goes here and there 

     synchronized (database) { 
      //Perform deletion code 
     } 
    } 

是因为remove方法我们正在使用不同的参考FlightFileAccess我们也使用不同的参考RandomAccessFile？

这意味着，有FlightFileAccess静态服务不会成为这里synchronize在RandomAccessFile，因为它是每次所以每个DataflightsService实例将做随机访问的文件忽略了同步他们的事一个新的。与在静态启动器中实例化FlightFileAccess相反。我对吗？

我会尽可能多的解释，以提供最好的方式来实例化DataflightsService多少倍（我们可以说想象每个客户端都有自己的实例DataflightsService），然后才能够同步在一个文件中删除例如，以便没有几个客户访问该文件的混乱。对不起，我需要为每个客户端添加一个DataflightsService bc没有cookie。

Answer 1

您的示例将不会编译，因为构造函数的名称与类不匹配。但是如果你的意思是命名构造函数public DataflightsService()，那么问题的一部分就是每次创建一个新对象时都要覆盖静态变量。

听起来你想让这个静态变量只被初始化一次。通常你只会直接与private static final FlightFileAccess fileAccess = new FlightFileAccess();分配变量，如果你想，如果你有一个构造函数添加更多的逻辑，你可以按如下方式使用静态初始化块：

public class Dataflights { 

    private static final FlightFileAccess fileAccess; 

    static { 
     // Static initializer block gets run once when the class is first referenced. 
     // Not usually used unless you want to add more logic besides just initializing variables. 
     fileAccess = new FlightFileAccess(); 
    } 

    private final String path; 
    public final int id; 

    public Dataflights(String path) { 
     this.path = path; 
     this.id = fileAccess.generateId(); 
    } 

    static class FlightFileAccess { 

    private volatile int nextId = 0; 
    synchronized public int generateId() { 
     return nextId++; 
    } 
    } 

    public static void main(String[] args) { 
    Dataflights d = new Dataflights("my/path"); 
    System.out.println("Id is: " + d.id); 
    } 
} 

有许多方法来处理争用。如果您不熟悉Java并发性，我推荐Java Concurrency in Practice。

您在FlightFileAccess类中处于正确的轨道。我看不到详细信息，但您也可能希望在remove()方法的签名中使用​​关键字来首先保护整个函数。然后，一旦你有了工作，使用更加紧密的目标块来减少必须单线程的代码量。