如何在Java中同步非静态方法变量（对象）

Question

I have one method which write to a file. I need to synchronize file object

class MessageFile{

public static final String  fileName="Main.html"
@AutoWired
AppConifg appconfig;

 public boolean writeToFile(String fileContent) throws  Exception{

        String path = appConfig.getNewsPath() + File.separator + fileName; // getNewsPath is non-static method
        final  File alertFile= new File(path);
        FileOutputStream out = null;
        synchronized (alertFile) {
          if (!alertFile.exists()) {
              alertFile.createNewFile();
          }
          try {
              out = new FileOutputStream(alertFile, false);
              out.write(fileContent.getBytes());
              out.flush();
          } finally {
              if (out != null) {
                  out.close();
              }
          }
      }
        return true;
    }


    }

But above code won`t take lock exclusive lock on file object as another instance of this class can have lock on this class and write to file. So I want to how handle this case ? I found one workaround creating a temporary file name appending time stamp (so temporary file name will be always unique) and after writing content to it , will first delete original file and then rename temporary file to original file name.

Answer 1

如果它是唯一访问文件的对象，则可以尝试在MessageFile.class上进行同步。

Answer 2

You are creating new File object ( alertFile ) every time method is run, so the lock does nothing as it is different every time method is run - you need to have static File instance shared across all method calls.

If path can be different every time the method is run, you could create static Map<String, File> instance and use it like this:

1. Get path of the file.
2. If there is no File associated with this path, create it.
3. Otherwise, recover existing File instance from map.
4. Use this File as a lock and do operations on it.

Example based on modified answer:

class MessageFile{

    public static final String  fileName="Main.html"
    @AutoWired
    AppConifg appconfig;

    private static final Map<String, File> filesMap = new HashMap<>();

    public boolean writeToFile(String fileContent) throws  Exception{

        String path = appConfig.getNewsPath() + File.separator + fileName; // getNewsPath is non-static method

        final File alertFile;
        synchronized(filesMap) {
            if (filesMap.containsKey(path)) {
                alertFile = filesMap.get(path);
            }
            else {
                alertFile = new File(path);
                filesMap.put(path, alertFile);
            }
        }

        FileOutputStream out = null;
        synchronized (alertFile) {
            if (!alertFile.exists()) {
                alertFile.createNewFile();
            }
            try {
                out = new FileOutputStream(alertFile, false);
                out.write(fileContent.getBytes());
                out.flush();
            } finally {
                if (out != null) {
                    out.close();
                }
            }
        }
        return true;
    }


}

Answer 3

Your program does not get exclusive lock on file because you are using synchronized on a local variable alertFile that is not shared between instances of the class MessageFile (each object has its own alertFile ). You have two possibilities to solve this:

1- Create some static object and synchronize on it (you may use fileName as it is already there).

2- Having a references in all the objects that point to the same object (passed in the constructor, for example) and synchronize on it.

Answer 4

Synchronize on the class level object ie MessageFile.class or use a static synchronize method wrtietofile() . it will make sure only one thread writes into the file at a time . it also guarantees the lock will be released once the entire data is written to the file by a thread .