Java同步类中的方法

基本上，我的层次结构是我有一个类a，它启动类B的100个线程，类B使用一个名为

FileCreator

的类

FileCreator

类有一个名为

writeToFile（）

的方法，该方法是同步的。 这是我在类B中实例化它的方式：

FileCreator newFile = new FileCreator(downloadFolder, content, page.getWebURL());
newFile.writeToFile();

现在我的问题是

writeToFile（）

实际上没有同步。基本上这就是我对我的

writeToFile（）所做的

但是，我在控制台中得到了以下结果：

Thread accessed
Thread accessed
Thread FINISHED!
Thread FINISHED!

所以它不是真正同步的。因为这些类是由不同的线程访问的，所以我假设这是导致问题的原因。是否有一种方法可以真正同步我的方法，以便一次只能有一次访问？
它是基于每个实例进行同步的<代码>同步

在实例方法上表示

synchronized(this) {
    ...
}

但由于您有100个实例，因此没有一个实例阻塞。您需要在共享对象上进行同步。将

锁

对象传递给每个实例，或者只创建一个传递给每个

线程的实例<代码>在该实例上同步。
我将使用“虚拟”对象并在其上同步块级别效率更高，因为它不会锁定整个方法。

Object xLock = new Object(); // !!! in you main thread

....

public void writeToFile() {
    synchronized(xLock ){
      System.out.println("Thread accessed");
      //Some stuff here
      System.out.println("Thread FINISHED!");
    }       
}

但你也可以写：

 public void writeToFile() {
    synchronized(this){
      System.out.println("Thread accessed");
      //Some stuff here
      System.out.println("Thread FINISHED!");
    }       
  }

}

请记住，
xLock
应该在主线程中启动

作为参考

=========================

方法级

块级

查看我的编辑，只有
synchronized（xLock）{/*..*/}
是的，我刚刚理解。所以我应该创建一个单例xLock？是的，只需创建一个
对象
像
对象锁=新对象（）
并使用上述方法。您是否创建了
对象xLock=新对象（）
在主类
A
中？好的，我刚刚修复了它。很抱歉，这是我的单身问题：）
 public void writeToFile() {
    synchronized(this){
      System.out.println("Thread accessed");
      //Some stuff here
      System.out.println("Thread FINISHED!");
    }       
  }

class MethodLevel {

  //shared among threads
SharedResource x, y ;

public void synchronized method1() {
   //multiple threads can't access
}
public void synchronized method2() {
  //multiple threads can't access
}

 public void method3() {
  //not synchronized
  //multiple threads can access
 }
}

class BlockLevel {
  //shared among threads
  SharedResource x, y ;

  //dummy objects for locking
  Object xLock = new Object();
  Object yLock = new Object();

    public void method1() {
     synchronized(xLock){
    //access x here. thread safe
    }

    //do something here but don't use SharedResource x, y
    // because will not be thread-safe
     synchronized(xLock) {
       synchronized(yLock) {
      //access x,y here. thread safe
      }
     }

     //do something here but don't use SharedResource x, y
     //because will not be thread-safe
    }//end of method1
 }