IO vs NIO

జావా IO ఎందుకు చెడ్డది?

IO (ఇన్‌పుట్ & అవుట్‌పుట్) API అనేది జావా API, ఇది డెవలపర్‌లకు స్ట్రీమ్‌లతో పని చేయడాన్ని సులభతరం చేస్తుంది. మేము కొంత డేటాను స్వీకరిస్తాము (ఉదాహరణకు, మొదటి పేరు, మధ్య పేరు, చివరి పేరు) మరియు మనం దానిని ఫైల్‌కి వ్రాయాలి — java.ioని ఉపయోగించడానికి సమయం ఆసన్నమైంది .

కానీ జావా 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 ని విసిరేలా చేయండి ( కనుక ఇది ఉన్నత స్థాయిలో నిర్వహించబడుతుంది).

జావా NIOకి చేరుకోవడం మరియు అది జావా IOతో ఎలా పోలుస్తుంది

Java NIO , లేదా జావా నాన్-బ్లాకింగ్ I/O (లేదా కొన్నిసార్లు జావా న్యూ I/O) అధిక-పనితీరు I/O కార్యకలాపాల కోసం రూపొందించబడింది.

జావా IO పద్ధతులు మరియు వాటిని భర్తీ చేసే వాటిని సరిపోల్చండి .

ముందుగా, జావా 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());
}

ఫైల్‌ఇన్‌పుట్‌స్ట్రీమ్ క్లాస్ అనేది ఫైల్ నుండి డేటాను చదవడానికి ఉద్దేశించబడింది . ఇది ఇన్‌పుట్‌స్ట్రీమ్ క్లాస్‌ను వారసత్వంగా పొందుతుంది మరియు అందువల్ల దాని అన్ని పద్ధతులను అమలు చేస్తుంది. ఫైల్ తెరవబడకపోతే, FileNotFoundException విసిరివేయబడుతుంది.

అవుట్‌పుట్‌స్ట్రీమ్ క్లాస్

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 క్లాస్ స్ట్రీమ్‌ల నుండి అక్షర డేటాను చదవడానికి అనుమతిస్తుంది మరియు ఫైల్‌రైటర్ క్లాస్ అక్షర స్ట్రీమ్‌లను వ్రాయడానికి ఉపయోగించబడుతుంది. కింది కోడ్ ఫైల్ నుండి ఎలా వ్రాయాలో మరియు చదవాలో చూపుతుంది:

        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 కనెక్షన్ ద్వారా పని చేసే ఛానెల్

• SocketChannel — 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);

కాబట్టి మేము మా సెలెక్టర్‌ని సృష్టించి, దానిని SelectableChannel కి కనెక్ట్ చేస్తాము .

సెలెక్టర్‌తో ఉపయోగించడానికి, ఛానెల్ తప్పనిసరిగా నాన్-బ్లాకింగ్ మోడ్‌లో ఉండాలి. ఫైల్‌చానెల్‌ను నాన్-బ్లాకింగ్ మోడ్‌లో ఉంచలేనందున , మీరు సెలెక్టర్‌తో FileChannelని ఉపయోగించలేరని దీని అర్థం . కానీ సాకెట్ ఛానెల్‌లు బాగా పని చేస్తాయి.

మా ఉదాహరణలో సెలెక్షన్‌కీ అనేది ఛానెల్‌లో నిర్వహించగల కార్యకలాపాల సమితి అని ఇక్కడ పేర్కొనండి . ఎంపిక కీ ఛానెల్ స్థితిని మాకు తెలియజేస్తుంది.

సెలెక్షన్‌కీ రకాలు

• 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 వేగాన్ని పోల్చడానికి చిన్న మరియు పెద్ద ఫైల్‌లలో దీనిని పరీక్షిద్దాం .

కాపీ చేయడానికి కోడ్, జావా 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));
}

చిన్న ఫైల్‌తో ప్రారంభిద్దాం.

Java IO యొక్క అమలు సమయం సగటున 1 మిల్లీసెకన్లు. పరీక్షను అనేకసార్లు అమలు చేయడం ద్వారా, మేము 0 నుండి 2 మిల్లీసెకన్ల ఫలితాలను పొందుతాము.

Java NIO కోసం అమలు సమయం చాలా ఎక్కువ. సగటు సమయం 11 మిల్లీసెకన్లు. ఫలితాలు 9 నుండి 16 వరకు ఉన్నాయి. ఎందుకంటే Java IO మా ఆపరేటింగ్ సిస్టమ్ కంటే భిన్నంగా పనిచేస్తుంది. IO ఫైల్‌లను ఒక్కొక్కటిగా కదిలిస్తుంది మరియు ప్రాసెస్ చేస్తుంది, కానీ ఆపరేటింగ్ సిస్టమ్ డేటాను ఒక పెద్ద భాగంలో పంపుతుంది. NIO పేలవంగా పనిచేసింది ఎందుకంటే ఇది బఫర్-ఆధారితమైనది, IO లాగా స్ట్రీమ్-ఓరియెంటెడ్ కాదు .

మరియు Java NIO.2 కోసం మా పరీక్షను కూడా అమలు చేద్దాం . జావా NIO తో పోలిస్తే NIO.2 ఫైల్ నిర్వహణను మెరుగుపరిచింది . అందుకే నవీకరించబడిన లైబ్రరీ అటువంటి విభిన్న ఫలితాలను అందిస్తుంది:

ఇప్పుడు మన పెద్ద ఫైల్, 521 MB వీడియోని పరీక్షించడానికి ప్రయత్నిద్దాం. పని సరిగ్గా అదే విధంగా ఉంటుంది: ఫైల్ను మరొక ఫోల్డర్కు కాపీ చేయండి. చూడు!

Java IO కోసం ఫలితాలు :

మరియు ఇక్కడ జావా NIO ఫలితం :

Java NIO మొదటి పరీక్షలో ఫైల్‌ను 9 రెట్లు వేగంగా హ్యాండిల్ చేసింది. పునరావృత పరీక్షలు దాదాపు అదే ఫలితాలను చూపించాయి.

మరియు మేము మా పరీక్షను Java NIO.2 లో కూడా ప్రయత్నిస్తాము :

ఈ ఫలితం ఎందుకు? ఎందుకంటే అవి వేర్వేరు ప్రయోజనాలను అందిస్తాయి కాబట్టి వాటి మధ్య పనితీరును పోల్చడం మాకు చాలా అర్ధవంతం కాదు. NIO అనేది మరింత వియుక్తమైన తక్కువ-స్థాయి I/O, అయితే NIO.2 ఫైల్ మేనేజ్‌మెంట్ వైపు దృష్టి సారించింది.

సారాంశం

బ్లాక్‌ల లోపల ఉపయోగించడం వల్ల ఫైల్‌లతో పనిచేసేటప్పుడు Java NIO గణనీయంగా మరింత సమర్థవంతంగా పనిచేస్తుందని మేము సురక్షితంగా చెప్పగలం . మరొక ప్లస్ ఏమిటంటే, NIO లైబ్రరీ రెండు భాగాలుగా విభజించబడింది: ఒకటి ఫైల్‌లతో పనిచేయడానికి, మరొకటి నెట్‌వర్క్‌తో పనిచేయడానికి.

Java NIO.2 ఫైల్‌లతో పని చేయడానికి కొత్త API అనేక ఉపయోగకరమైన లక్షణాలను అందిస్తుంది:

• పాత్ ఉపయోగించి మరింత ఉపయోగకరమైన ఫైల్ సిస్టమ్ చిరునామా ,

• అనుకూల ఫైల్ సిస్టమ్ ప్రొవైడర్‌ని ఉపయోగించి జిప్ ఫైల్‌ల నిర్వహణ గణనీయంగా మెరుగుపడింది,

• ప్రత్యేక ఫైల్ లక్షణాలకు ప్రాప్యత,

• ఒకే స్టేట్‌మెంట్‌తో మొత్తం ఫైల్‌ను చదవడం, ఒకే స్టేట్‌మెంట్‌తో ఫైల్‌ను కాపీ చేయడం మొదలైన అనేక అనుకూలమైన పద్ధతులు.

ఇది ఫైల్‌లు మరియు ఫైల్ సిస్టమ్‌లకు సంబంధించినది మరియు ఇది చాలా ఉన్నత స్థాయి.

నేటి వాస్తవికత ఏమిటంటే, Java NIO దాదాపు 80-90% ఫైల్‌లతో పని చేస్తుంది, అయినప్పటికీ Java IO వాటా ఇప్పటికీ ముఖ్యమైనది.

💡 PS ఈ పరీక్షలు MacBook Pro 14" 16/512లో అమలు చేయబడ్డాయి. ఆపరేటింగ్ సిస్టమ్ మరియు వర్క్‌స్టేషన్ స్పెసిఫికేషన్‌ల ఆధారంగా పరీక్ష ఫలితాలు భిన్నంగా ఉండవచ్చు.