一个任务在获得该对象的锁后，不释放，在调用该对象的其他synchronized方法还可以再次获得对象

一个任务在获得该对象的锁后，不释放，在调用该对象的其他synchronized方法还可以再次获得对象。

example：

package com.Thread.program;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class SynchronizedTryAgain {
     public static void main(String[] args) {
        try {
            new SynchronizedTryAgain().write("hi camille!");
        } catch (IOException e) {
            e.printStackTrace();
        }
     }
     
     public synchronized  void  write(String data)throws IOException{
         File file=new File("E:/TestJava/TestSyn.txt");
         FileWriter fw=null;
         try {
            fw=new FileWriter(file);
            fw.write(data);
            fw.flush();
            read(file);
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            fw.close();
        }
     }
    
     public synchronized void read(File file) throws IOException{
         FileReader fr=null;
         StringBuffer sb=new StringBuffer();
         try {
            fr=new FileReader(file);
            char[]cbuf=new char[1024];
            while((fr.read(cbuf))!=-1){
                   sb.append(cbuf);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally{
            System.out.println(sb.toString());
             fr.close();    
        }
     }
}