IO vs NIO

ஜாவா ஐஓ ஏன் மிகவும் மோசமாக உள்ளது?

IO (உள்ளீடு & வெளியீடு) API என்பது Java API ஆகும், இது டெவலப்பர்கள் ஸ்ட்ரீம்களுடன் வேலை செய்வதை எளிதாக்குகிறது. நாம் சில தரவுகளைப் பெறுகிறோம் (உதாரணமாக, முதல் பெயர், நடுப்பெயர், கடைசி பெயர்) மற்றும் அதை ஒரு கோப்பில் எழுத வேண்டும் - java.io ஐப் பயன்படுத்துவதற்கான நேரம் வந்துவிட்டது .

ஆனால் ஜாவா ஐஓ அதன் குறைபாடுகளைக் கொண்டுள்ளது, எனவே அவை ஒவ்வொன்றையும் பற்றி பேசலாம்:

1. உள்ளீடு/வெளியீட்டிற்கான அணுகலைத் தடுக்கிறது. சிக்கல் என்னவென்றால், ஒரு டெவலப்பர் Java IO ஐப் பயன்படுத்தி ஒரு கோப்பைப் படிக்க அல்லது எழுத முயற்சிக்கும்போது , ​​​​அது கோப்பைப் பூட்டி, வேலை முடியும் வரை அதற்கான அணுகலைத் தடுக்கிறது.
2. மெய்நிகர் கோப்பு முறைமைகளுக்கு ஆதரவு இல்லை.
3. இணைப்புகளுக்கு ஆதரவு இல்லை.
4. ஏராளமான மற்றும் சரிபார்க்கப்பட்ட விதிவிலக்குகள்.

கோப்புகளுடன் பணிபுரிவது எப்போதும் விதிவிலக்குகளுடன் வேலை செய்வதை உள்ளடக்குகிறது: எடுத்துக்காட்டாக, ஏற்கனவே இருக்கும் ஒரு புதிய கோப்பை உருவாக்க முயற்சிப்பது IOException . இந்த வழக்கில், பயன்பாடு தொடர்ந்து இயங்க வேண்டும் மற்றும் கோப்பை ஏன் உருவாக்க முடியவில்லை என்பதை பயனருக்கு தெரிவிக்க வேண்டும்.

try {
	File.createTempFile("prefix", "");
} catch (IOException e) {
	// Handle the IOException
}

/**
 * Creates an empty file in the default temporary-file directory 
 * any exceptions will be ignored. This is typically used in finally blocks. 
 * @param prefix 
 * @param suffix 
 * @throws IOException - If a file could not be created
 */
public static File createTempFile(String prefix, String suffix) 
throws IOException {
...
}

கோப்பை உருவாக்க முடியாத போது, ​​createTempFile முறை IOException ஐ எறிவதை இங்கு காண்கிறோம் . இந்த விதிவிலக்கு சரியான முறையில் கையாளப்பட வேண்டும். இந்த முறையை ட்ரை-கேட்ச் பிளாக்கிற்கு வெளியே அழைக்க முயற்சித்தால் , கம்பைலர் ஒரு பிழையை உருவாக்கி, அதைச் சரிசெய்வதற்கான இரண்டு விருப்பங்களைப் பரிந்துரைக்கும்: இந்த முறையை ஒரு முயற்சி-பிடிப்பு பிளாக்கில் மடிக்கவும் அல்லது File.createTempFile ஐ அழைக்கும் முறையை IOException ( IOException ) செய்யவும். எனவே அதை உயர் மட்டத்தில் கையாள முடியும்).

Java NIO க்கு வந்தடைதல் மற்றும் அது Java IO உடன் எவ்வாறு ஒப்பிடுகிறது

Java NIO , அல்லது Java Non-Blocking I/O (அல்லது சில நேரங்களில் Java New I/O) உயர் செயல்திறன் I/O செயல்பாடுகளுக்காக வடிவமைக்கப்பட்டுள்ளது.

ஜாவா ஐஓ முறைகள் மற்றும் அவற்றை மாற்றும் முறைகளை ஒப்பிடுவோம் .

முதலில், ஜாவா IO உடன் பணிபுரிவது பற்றி பேசலாம் :

இன்புட்ஸ்ட்ரீம் வகுப்பு

try(FileInputStream fin = new FileInputStream("C:/codegym/file.txt")){
    System.out.printf("File size: %d bytes \n", fin.available());
    int i=-1;
    while((i=fin.read())!=-1) {
        System.out.print((char)i);
    }   
} catch(IOException ex) {
    System.out.println(ex.getMessage());
}

FileInputStream வகுப்பு என்பது ஒரு கோப்பிலிருந்து தரவைப் படிப்பதற்காகும். இது InputStream வகுப்பைப் பெறுகிறது , எனவே அதன் அனைத்து முறைகளையும் செயல்படுத்துகிறது. கோப்பை திறக்க முடியாவிட்டால், FileNotFoundException எறியப்படும்.

OutputStream வகுப்பு

String text = "Hello world!"; // String to write
try(FileOutputStream fos = new FileOutputStream("C:/codegym/file.txt")){
    // Convert our string into bytes
    byte[] buffer = text.getBytes();
    fos.write(buffer, 0, buffer.length);
    System.out.println("The file has been written");
} catch(IOException ex) {
    System.out.println(ex.getMessage());
}

ஒரு கோப்பில் பைட்டுகளை எழுதுவதற்கான FileOutputStream வகுப்பு . இது OutputStream வகுப்பிலிருந்து பெறப்பட்டது .

வாசகர் மற்றும் எழுத்தாளர் வகுப்புகள்

FileReader வகுப்பு , ஸ்ட்ரீம்களிலிருந்து எழுத்துத் தரவைப் படிக்க உதவுகிறது, மேலும் FileWriter வகுப்பு எழுத்து ஸ்ட்ரீம்களை எழுதப் பயன்படுகிறது. ஒரு கோப்பிலிருந்து எப்படி எழுதுவது மற்றும் படிப்பது என்பதை பின்வரும் குறியீடு காட்டுகிறது:

        String fileName = "c:/codegym/Example.txt";

        // Create a FileWriter object
        try (FileWriter writer = new FileWriter(fileName)) {

            // Write content to file
            writer.write("This is a simple example\nin which we\nwrite to a file\nand read from a file\n");
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Create a FileReader object
        try (FileReader fr = new FileReader(fileName)) {
            char[] a = new char[200]; // Number of characters to read
            fr.read(a); // Read content into an array
            for (char c : a) {
                System.out.print(c); // Display characters one by one
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

இப்போது ஜாவா NIO பற்றி பேசலாம் :

சேனல்

Java IO இல் பயன்படுத்தப்படும் ஸ்ட்ரீம்களைப் போலன்றி , சேனல் என்பது இருவழி இடைமுகம், அதாவது, இது படிக்கவும் எழுதவும் முடியும். ஒரு Java NIO சேனல் பிளாக்கிங் மற்றும் பிளாக்கிங் அல்லாத இரண்டு முறைகளிலும் ஒத்திசைவற்ற தரவு ஓட்டத்தை ஆதரிக்கிறது.

RandomAccessFile aFile = new RandomAccessFile("C:/codegym/file.txt", "rw");
FileChannel inChannel = aFile.getChannel();

ByteBuffer buf = ByteBuffer.allocate(100);
int bytesRead = inChannel.read(buf);

while (bytesRead != -1) {
  System.out.println("Read: " + bytesRead);
  buf.flip();
	  while(buf.hasRemaining()) {
	      System.out.print((char) buf.get());
	  }
  buf.clear();
  bytesRead = inChannel.read(buf);
}
aFile.close();

இங்கே நாம் FileChannel ஐப் பயன்படுத்தினோம் . ஒரு கோப்பிலிருந்து தரவைப் படிக்க கோப்பு சேனலைப் பயன்படுத்துகிறோம். ஒரு கோப்புப் பொருளில் getChannel() முறையை அழைப்பதன் மூலம் மட்டுமே ஒரு கோப்பு சேனல் பொருளை உருவாக்க முடியும் - கோப்பு சேனல் பொருளை நேரடியாக உருவாக்க வழி இல்லை.

FileChannel க்கு கூடுதலாக , எங்களிடம் பிற சேனல் செயலாக்கங்கள் உள்ளன:

• FileChannel - கோப்புகளுடன் பணிபுரிய

• DatagramChannel — UDP இணைப்பில் வேலை செய்வதற்கான ஒரு சேனல்

• சாக்கெட் சேனல் - TCP இணைப்பில் வேலை செய்வதற்கான ஒரு சேனல்

• ServerSocketChannel ஆனது SocketChannel ஐக் கொண்டுள்ளதுமற்றும் இணைய சேவையகம் எவ்வாறு செயல்படுகிறது என்பதைப் போன்றது

தயவுசெய்து கவனிக்கவும்: FileChannel ஐ தடுக்காத பயன்முறைக்கு மாற்ற முடியாது. Java NIO இன் தடையற்ற பயன்முறையானது, சேனலில் இருந்து படிக்கும் தரவைக் கோருவதற்கும், தற்போது உள்ளதை மட்டுமே பெறுவதற்கும் உங்களை அனுமதிக்கிறது (அல்லது தரவு எதுவும் கிடைக்கவில்லை என்றால் எதுவும் இல்லை). அதாவது, SelectableChannel மற்றும் அதன் செயலாக்கங்களை இணைப்பு() முறையைப் பயன்படுத்தி தடுக்காத பயன்முறையில் வைக்கலாம் .

தேர்வாளர்

Java NIO ஆனது, எந்த சேனல் தரவை எழுதவும் படிக்கவும் தயாராக உள்ளது என்பதை அறியும் நூலை உருவாக்கும் திறனை அறிமுகப்படுத்தியது மற்றும் குறிப்பிட்ட சேனலை செயலாக்க முடியும். இந்த திறன் தேர்வாளர் வகுப்பைப் பயன்படுத்தி செயல்படுத்தப்படுகிறது.

Selector selector = Selector.open();
channel.configureBlocking(false); // Non-blocking mode
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

எனவே நாங்கள் எங்கள் தேர்வியை உருவாக்கி அதை தேர்ந்தெடுக்கக்கூடிய சேனலுடன் இணைக்கிறோம் .

தேர்வாளருடன் பயன்படுத்த, சேனல் தடையற்ற முறையில் இருக்க வேண்டும். இதன் பொருள் FileChannel ஐ ஒரு தேர்வாளருடன் பயன்படுத்த முடியாது , ஏனெனில் FileChannel ஐ தடுக்காத பயன்முறையில் வைக்க முடியாது. ஆனால் சாக்கெட் சேனல்கள் நன்றாக வேலை செய்யும்.

எங்கள் எடுத்துக்காட்டில் SelectionKey என்பது சேனலில் செய்யக்கூடிய செயல்பாடுகளின் தொகுப்பாகும் என்பதை இங்கே குறிப்பிடலாம் . தேர்வு விசை சேனலின் நிலையை அறிய உதவுகிறது.

SelectionKey வகைகள்

• SelectionKey.OP_CONNECT என்பது சேவையகத்துடன் இணைக்கத் தயாராக உள்ள சேனலைக் குறிக்கிறது.

• SelectionKey.OP_ACCEPT என்பது உள்வரும் இணைப்புகளை ஏற்கத் தயாராக உள்ள ஒரு சேனலாகும்.

• SelectionKey.OP_READ என்பது தரவைப் படிக்கத் தயாராக உள்ள சேனலைக் குறிக்கிறது.

• SelectionKey.OP_WRITE என்பது தரவை எழுதத் தயாராக உள்ள சேனலைக் குறிக்கிறது.

தாங்கல்

மேலும் செயலாக்கத்திற்காக தரவு ஒரு இடையகமாக வாசிக்கப்படுகிறது. ஒரு டெவலப்பர் இடையகத்தில் முன்னும் பின்னுமாக நகர முடியும், இது தரவைச் செயலாக்கும்போது இன்னும் கொஞ்சம் நெகிழ்வுத்தன்மையை அளிக்கிறது. அதே நேரத்தில், இடையகமானது சரியான செயலாக்கத்திற்குத் தேவையான அளவு தரவு உள்ளதா என்பதைச் சரிபார்க்க வேண்டும். மேலும், ஒரு இடையகத்தில் தரவைப் படிக்கும்போது, ​​இதுவரை செயலாக்கப்படாத தரவை அழிக்க வேண்டாம் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்.

ByteBuffer buf = ByteBuffer.allocate (2048); 
int bytesRead = channel.read(buf);
buf.flip(); // Change to read mode
while (buf.hasRemaining()) { 
	byte data = buf.get(); // There are methods for primitives 
}

buf.clear(); // Clear the buffer - now it can be reused

ஒரு இடையகத்தின் அடிப்படை பண்புகள்:

இப்போது Java NIO.2 இல் புதிதாக என்ன இருக்கிறது என்பதைப் பற்றி கொஞ்சம் பேசலாம் .

பாதை

பாதை என்பது கோப்பு முறைமையில் ஒரு பாதையைக் குறிக்கிறது. இது ஒரு கோப்பின் பெயர் மற்றும் அதற்கான பாதையை வரையறுக்கும் கோப்பகங்களின் பட்டியலைக் கொண்டுள்ளது.

Path relative = Paths.get("Main.java");
System.out.println("File: " + relative);
// Get the file system
System.out.println(relative.getFileSystem());

பாதைகள் என்பது ஒரு நிலையான முறையுடன் கூடிய மிகவும் எளிமையான வகுப்பாகும்: get() . அனுப்பப்பட்ட சரம் அல்லது URI இலிருந்து ஒரு பாதைப் பொருளைப் பெறுவதற்காக மட்டுமே இது உருவாக்கப்பட்டது

Path path = Paths.get("c:\\data\\file.txt");

கோப்புகள்

கோப்புகள் என்பது ஒரு கோப்பின் அளவை நேரடியாகப் பெறவும், கோப்புகளை நகலெடுக்கவும் மற்றும் பலவற்றைப் பெறவும் உதவும் ஒரு பயன்பாட்டு வகுப்பாகும்.

Path path = Paths.get("files/file.txt");
boolean pathExists = Files.exists(path);

கோப்பு முறை

கோப்பு முறைமை கோப்பு முறைமைக்கு ஒரு இடைமுகத்தை வழங்குகிறது. கோப்பு முறைமை பல்வேறு பொருட்களை உருவாக்குவதற்கான ஒரு தொழிற்சாலை போல் செயல்படுகிறது (பாதை,பாத்மேட்சர்,கோப்புகள்) கோப்பு முறைமையில் உள்ள கோப்புகள் மற்றும் பிற பொருட்களை அணுக இது உதவுகிறது.

try {
      FileSystem filesystem = FileSystems.getDefault();
      for (Path rootdir : filesystem.getRootDirectories()) {
          System.out.println(rootdir.toString());
      }
  } catch (Exception e) {
      e.printStackTrace();
  }

செயல்திறன் சோதனை

இந்த சோதனைக்கு, இரண்டு கோப்புகளை எடுத்துக் கொள்வோம். முதல் ஒரு சிறிய உரை கோப்பு, மற்றும் இரண்டாவது ஒரு பெரிய வீடியோ.

நாங்கள் ஒரு கோப்பை உருவாக்கி, சில வார்த்தைகளையும் எழுத்துக்களையும் சேர்ப்போம்:

எங்கள் கோப்பு மொத்தம் 42 பைட்டுகளை நினைவகத்தில் கொண்டுள்ளது:

இப்போது நம் கோப்பை ஒரு கோப்புறையிலிருந்து மற்றொரு கோப்புறைக்கு நகலெடுக்கும் குறியீட்டை எழுதுவோம். IO மற்றும் NIO மற்றும் NIO.2 இன் வேகத்தை ஒப்பிட சிறிய மற்றும் பெரிய கோப்புகளில் இதை சோதிப்போம் .

நகலெடுப்பதற்கான குறியீடு, Java IO ஐப் பயன்படுத்தி எழுதப்பட்டது :

public static void main(String[] args) {
        long currentMills = System.currentTimeMillis();
        long startMills = currentMills;
        File src = new File("/Users/IdeaProjects/testFolder/text.txt");
        File dst = new File("/Users/IdeaProjects/testFolder/text1.txt");
        copyFileByIO(src, dst);
        currentMills = System.currentTimeMillis();
        System.out.println("Execution time in milliseconds: " + (currentMills - startMills));
    }

    public static void copyFileByIO(File src, File dst) {
        try(InputStream inputStream = new FileInputStream(src);
            OutputStream outputStream = new FileOutputStream(dst)){

            byte[] buffer = new byte[1024];
            int length;
            // Read data into a byte array and then output to an OutputStream
            while((length = inputStream.read(buffer)) > 0) {
                outputStream.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

ஜாவா NIO க்கான குறியீடு இதோ :

public static void main(String[] args) {
        long currentMills = System.currentTimeMillis();
        long startMills = currentMills;

        File src = new File("/Users/IdeaProjects/testFolder/text.txt");
        File dst = new File("/Users/IdeaProjects/testFolder/text2.txt");
        // Code for copying using NIO
        copyFileByChannel(src, dst);
        currentMills = System.currentTimeMillis();
        System.out.println("Execution time in milliseconds: " + (currentMills - startMills));
    }

    public static void copyFileByChannel(File src, File dst) {
        // 1. Get a FileChannel for the source file and the target file
        try(FileChannel srcFileChannel  = new FileInputStream(src).getChannel();
            FileChannel dstFileChannel = new FileOutputStream(dst).getChannel()){
            // 2. Size of the current FileChannel
            long count = srcFileChannel.size();
            while(count > 0) {
                /**=============================================================
                 * 3. Write bytes from the source file's FileChannel to the target FileChannel
                 * 1. srcFileChannel.position(): the starting position in the source file, cannot be negative
                 * 2. count: the maximum number of bytes transferred, cannot be negative
                 * 3. dstFileChannel: the target file
                 *==============================================================*/
                long transferred = srcFileChannel.transferTo(srcFileChannel.position(),
                        count, dstFileChannel);
                // 4. After the transfer is complete, change the position of the original file to the new one
                srcFileChannel.position(srcFileChannel.position() + transferred);
                // 5. Calculate how many bytes are left to transfer
                count -= transferred;
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

ஜாவா NIO.2 க்கான குறியீடு :

public static void main(String[] args) {
  long currentMills = System.currentTimeMillis();
  long startMills = currentMills;

  Path sourceDirectory = Paths.get("/Users/IdeaProjects/testFolder/test.txt");
  Path targetDirectory = Paths.get("/Users/IdeaProjects/testFolder/test3.txt");
  Files.copy(sourceDirectory, targetDirectory);

  currentMills = System.currentTimeMillis();
  System.out.println("Execution time in milliseconds: " + (currentMills - startMills));
}

சிறிய கோப்புடன் ஆரம்பிக்கலாம்.

ஜாவா ஐஓவின் இயக்க நேரம் சராசரியாக 1 மில்லி விநாடிகள். சோதனையை பல முறை இயக்குவதன் மூலம், 0 முதல் 2 மில்லி விநாடிகள் வரை முடிவுகளைப் பெறுகிறோம்.

Java NIO க்கு செயல்படுத்தும் நேரம் மிக நீண்டது. சராசரி நேரம் 11 மில்லி விநாடிகள். முடிவுகள் 9 முதல் 16 வரை இருந்தது. இதற்குக் காரணம் Java IO ஆனது நமது இயங்குதளத்தை விட வித்தியாசமாக வேலை செய்கிறது. IO கோப்புகளை ஒவ்வொன்றாக நகர்த்துகிறது மற்றும் செயலாக்குகிறது, ஆனால் இயக்க முறைமை தரவுகளை ஒரு பெரிய துண்டாக அனுப்புகிறது. NIO மோசமாகச் செயல்பட்டது, ஏனெனில் இது IO போன்று ஸ்ட்ரீம் சார்ந்ததாக இல்லாமல், தாங்கல் சார்ந்ததாக உள்ளது .

மேலும் Java NIO.2 க்கான சோதனையை இயக்குவோம் . ஜாவா NIO உடன் ஒப்பிடும்போது NIO.2 கோப்பு நிர்வாகத்தை மேம்படுத்தியுள்ளது . அதனால்தான் புதுப்பிக்கப்பட்ட நூலகம் இத்தகைய மாறுபட்ட முடிவுகளைத் தருகிறது:

இப்போது நமது பெரிய கோப்பை, 521 எம்பி வீடியோவை சோதிக்க முயற்சிப்போம். பணி சரியாகவே இருக்கும்: கோப்பை மற்றொரு கோப்புறையில் நகலெடுக்கவும். பார்!

Java IO க்கான முடிவுகள் :

Java NIO க்கான முடிவு இங்கே :

ஜாவா NIO முதல் சோதனையில் கோப்பை 9 மடங்கு வேகமாக கையாண்டது. மீண்டும் மீண்டும் சோதனைகள் தோராயமாக அதே முடிவுகளைக் காட்டின.

ஜாவா NIO.2 இல் எங்கள் சோதனையை முயற்சிப்போம் :

ஏன் இந்த முடிவு? ஏனென்றால், அவை வெவ்வேறு நோக்கங்களுக்காக செயல்படுவதால், அவற்றுக்கிடையேயான செயல்திறனை ஒப்பிட்டுப் பார்ப்பதில் எங்களுக்கு அதிக அர்த்தமில்லை. NIO என்பது மிகவும் சுருக்கமான குறைந்த-நிலை I/O ஆகும், அதே நேரத்தில் NIO.2 கோப்பு மேலாண்மையை நோக்கியதாக உள்ளது.

சுருக்கம்

ஜாவா NIO கோப்புகளுடன் பணிபுரியும் போது, ​​தொகுதிகளின் உள்ளே பயன்படுத்தப்படுவதால், மிகவும் திறமையானதாக இருக்கும் என்று நாம் பாதுகாப்பாக சொல்லலாம் . மற்றொரு பிளஸ் என்னவென்றால், NIO நூலகம் இரண்டு பகுதிகளாகப் பிரிக்கப்பட்டுள்ளது: ஒன்று கோப்புகளுடன் பணிபுரிய, மற்றொன்று பிணையத்துடன் வேலை செய்ய.

கோப்புகளுடன் வேலை செய்வதற்கான Java NIO.2 இன் புதிய API பல பயனுள்ள அம்சங்களை வழங்குகிறது:

• பாதையைப் பயன்படுத்தி மிகவும் பயனுள்ள கோப்பு முறைமை முகவரி ,

• தனிப்பயன் கோப்பு முறைமை வழங்குநரைப் பயன்படுத்தி ஜிப் கோப்புகளைக் கையாளுதல் கணிசமாக மேம்படுத்தப்பட்டது,

• சிறப்பு கோப்பு பண்புகளுக்கான அணுகல்,

• ஒரே அறிக்கையுடன் முழு கோப்பையும் படிப்பது, ஒரே அறிக்கையுடன் கோப்பை நகலெடுப்பது போன்ற பல வசதியான முறைகள்.

இது கோப்புகள் மற்றும் கோப்பு முறைமைகளைப் பற்றியது, மேலும் இது மிக உயர்ந்த மட்டத்தில் உள்ளது.

இன்றைய யதார்த்தம் என்னவென்றால், ஜாவா ஐஓவின் பங்கு இன்னும் குறிப்பிடத்தக்கதாக இருந்தாலும், ஜாவா என்ஐஓ கோப்புகளுடன் சுமார் 80-90% வேலை செய்கிறது .

💡 PS இந்த சோதனைகள் MacBook Pro 14" 16/512 இல் இயக்கப்பட்டன. இயக்க முறைமை மற்றும் பணிநிலைய விவரக்குறிப்புகளின் அடிப்படையில் சோதனை முடிவுகள் வேறுபடலாம்.