Files.walkFileTree (जावा या स्कैला) के समानांतर संस्करण

Question

क्या किसी को जावा फाइलों के समानांतर समकक्ष के बारे में पता है। वाल्कफाइल ट्री या कुछ ऐसा ही है? यह जावा या स्कैला पुस्तकालय हो सकता है।

Answer 1

मान लीजिए कि प्रत्येक फ़ाइल पर कॉलबैक निष्पादित करना पर्याप्त है।

यह कोड फ़ाइल सिस्टम में लूप को संभाल नहीं करेगा - आपको उस रजिस्ट्री की आवश्यकता होगी जहां आप इसके लिए गए हैं (उदा। java.util.concurrent.ConcurrentHashMap)। उन सभी प्रकार के सुधार हैं जिन्हें आप जोड़ सकते हैं, जैसे चुपचाप उन्हें अनदेखा करने की बजाय अपवादों की रिपोर्ट करना।

import java.io.File 
import scala.util._ 
def walk(f: File, callback: File => Unit, pick: File => Boolean = _ => true) { 
    Try { 
    val (dirs, fs) = f.listFiles.partition(_.isDirectory) 
    fs.filter(pick).foreach(callback) 
    dirs.par.foreach(f => walk(f, callback, pick)) 
    } 
} 

एक foreach के बजाय एक गुना का उपयोग करके फ़ाइलें एकत्रित काफी कठिन नहीं है, लेकिन मैं छोड़ कि पाठक के लिए एक व्यायाम के रूप। (ConcurrentLinkedQueue शायद उन सभी को कॉलबैक में स्वीकार करने के लिए पर्याप्त तेज़ है, भले ही आपके पास वास्तव में धीमी धागे और एक भयानक फाइल सिस्टम हो।)

Answer 2

जैसा कि अन्य ने इंगित किया है, एक फ़ाइल पेड़ चलाना लगभग निश्चित रूप से सीपीयू बाध्य की बजाय आईओ बाध्य है, इसलिए एक बहुप्रचारित फ़ाइल पेड़ चलने के लाभ संदिग्ध हैं। लेकिन अगर आप वास्तव में चाहते थे, तो आप शायद ForkJoinPool या इसी तरह के साथ अपना खुद का रोल कर सकते हैं।

import java.io.IOException; 
import java.nio.file.FileVisitResult; 
import java.nio.file.Files; 
import java.nio.file.Path; 
import java.nio.file.Paths; 
import java.nio.file.SimpleFileVisitor; 
import java.nio.file.attribute.BasicFileAttributes; 
import java.util.ArrayList; 
import java.util.List; 
import java.util.concurrent.ForkJoinPool; 
import java.util.concurrent.RecursiveAction; 

public class MultiThreadedFileTreeWalk { 
    private static class RecursiveWalk extends RecursiveAction { 
     private static final long serialVersionUID = 6913234076030245489L; 
     private final Path dir; 

     public RecursiveWalk(Path dir) { 
      this.dir = dir; 
     } 

     @Override 
     protected void compute() { 
      final List<RecursiveWalk> walks = new ArrayList<>(); 
      try { 
       Files.walkFileTree(dir, new SimpleFileVisitor<Path>() { 
        @Override 
        public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException { 
         if (!dir.equals(RecursiveWalk.this.dir)) { 
          RecursiveWalk w = new RecursiveWalk(dir); 
          w.fork(); 
          walks.add(w); 

          return FileVisitResult.SKIP_SUBTREE; 
         } else { 
          return FileVisitResult.CONTINUE; 
         } 
        } 

        @Override 
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { 
         System.out.println(file + "\t" + Thread.currentThread()); 
         return FileVisitResult.CONTINUE; 
        } 
       }); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 

      for (RecursiveWalk w : walks) { 
       w.join(); 
      } 
     } 
    } 

    public static void main(String[] args) throws IOException { 
     RecursiveWalk w = new RecursiveWalk(Paths.get(".").toRealPath()); 
     ForkJoinPool p = new ForkJoinPool(); 
     p.invoke(w); 
    } 
} 

यह उदाहरण प्रत्येक निर्देशिका को एक अलग थ्रेड पर चलता है। जावा 7 की fork/join लाइब्रेरी के लिए यहां ट्यूटोरियल है।

Answer 3

यह अभ्यास स्कैला उत्तर के रूप में संक्षिप्त नहीं है और न ही जावा जैसे जावा उत्तर के रूप में ।

यहां विचार था कि प्रति डिवाइस धागे की तरह कुछ समानांतर चलना शुरू करें।

वॉकर फोर्कजोइनपूल धागे पर हैं, इसलिए जब वे प्रत्येक पथ परीक्षण के लिए भविष्य को निकाल देते हैं, तो वे पूल पर फोर्क किए गए कार्य होते हैं। जब निर्देशिका निर्देशिका को पढ़ती है, तो फाइलों की तलाश करते समय निर्देशिका परीक्षण प्रबंधित अवरोधन का उपयोग करता है।

परिणाम भविष्य के पथ परीक्षण के आधार पर एक वादा पूरा करके वापस किया जाता है। (खाली हाथ पूरा करने का पता लगाने के लिए यहां कोई तंत्र नहीं है।)

एक और दिलचस्प परीक्षण में ज़िप फ़ाइलों को पढ़ने में शामिल होगा, क्योंकि डिकंप्रेशन कुछ सीपीयू खाएगा।

मुझे आश्चर्य है कि paulp will do something clever with deep listing है।

import util._ 
import collection.JavaConverters._ 
import concurrent.{ TimeoutException => Timeout, _ } 
import concurrent.duration._ 
import ExecutionContext.Implicits._ 
import java.io.IOException 
import java.nio.file.{ FileVisitResult => Result, _ } 
import Result.{ CONTINUE => Go, SKIP_SUBTREE => Prune, TERMINATE => Stop } 
import java.nio.file.attribute.{ BasicFileAttributes => BFA } 

object Test extends App { 
    val fileSystem = FileSystems.getDefault 
    val starts = (if (args.nonEmpty) args.toList else mounts) map (s => (fileSystem getPath s)) 
    val p = Promise[(Path, BFA)] 

    def pathTest(path: Path, attrs: BFA) = 
    if (attrs.isDirectory) { 
     val entries = blocking { 
     val res = Files newDirectoryStream path 
     try res.asScala.toList finally res.close() 
     } 
     List("hello","world") forall (n => entries exists (_.getFileName.toString == n)) 
    } else { 
     path.getFileName.toString == "enough" 
    } 

    def visitor(root: Path) = new SimpleFileVisitor[Path] { 
    def stopOrGo = if (p.isCompleted) Stop else Go 
    def visiting(path: Path, attrs: BFA) = { 
     future { pathTest(path, attrs) } onComplete { 
     case Success(true) => p trySuccess (path, attrs) 
     case Failure(e) => p tryFailure e 
     case _    => 
     } 
     stopOrGo 
    } 
    override def preVisitDirectory(dir: Path, attrs: BFA) = (
     if ((starts contains dir) && dir != root) Prune 
     else visiting(dir, attrs) 
    ) 
    override def postVisitDirectory(dir: Path, e: IOException) = { 
     if (e != null) p tryFailure e 
     stopOrGo 
    } 
    override def visitFile(file: Path, attrs: BFA) = visiting(file, attrs) 
    } 
    //def walk(p: Path): Path = Files walkFileTree (p, Set().asJava, 10, visitor(p)) 
    def walk(p: Path): Path = Files walkFileTree (p, visitor(p)) 

    def show(store: FileStore) = { 
    val ttl = store.getTotalSpace/1024 
    val used = (store.getTotalSpace - store.getUnallocatedSpace)/1024 
    val avail = store.getUsableSpace/1024 
    Console println f"$store%-40s $ttl%12d $used%12d $avail%12d" 
    store 
    } 
    def mounts = { 
    val devs = for { 
     store <- fileSystem.getFileStores.asScala 
     if store.name startsWith "/dev/" 
     if List("ext4","fuseblk") contains store.`type` 
    } yield show(store) 
    val devstr = """(\S+) \((.*)\)""".r 
    (devs.toList map (_.toString match { 
     case devstr(name, dev) if devs.toList exists (_.name == dev) => Some(name) 
     case s => Console println s"Bad dev str '$s', skipping" ; None 
    })).flatten 
    } 

    starts foreach (f => future (walk(f))) 

    Try (Await result (p.future, 20.seconds)) match { 
    case Success((name, attrs)) => Console println s"Result: ${if (attrs.isDirectory) "dir" else "file"} $name" 
    case Failure(e: Timeout) => Console println s"No result: timed out." 
    case Failure(t)    => Console println s"No result: $t." 
    } 
}