If you have the directory name in myDirectoryPath,

import java.io.File;
...
  File dir = new File(myDirectoryPath);
  File[] directoryListing = dir.listFiles();
  if (directoryListing != null) {
    for (File child : directoryListing) {
      // Do something with child
    }
  } else {
    // Handle the case where dir is not really a directory.
    // Checking dir.isDirectory() above would not be sufficient
    // to avoid race conditions with another process that deletes
    // directories.
  }

FolderProcessor

if (inputfile.isDirectory()) {
    processFolder(filePath, outputPath + filename);
}

This is why you're not seeing any benefits from parallelism; you're processing subfolders within the same thread! But even so, you'd be making a new ExecutorService each invocation; pool should be a class-level field:

private final ExecutorService pool;

public FolderProcessor(ExecutorService pool){
    this.pool = pool;
}

After running some tests, I noticed that your path resolution is broken; the path separator isn't being added for subpaths! You can use all the operating system's rules by switching to Paths:

String filePath = inputFolder.toPath().resolve(filename).toString();

Some quick cleanup and a change to lambda notation (Java 8 is so much cleaner):

class FolderProcessor{
    private static final Logger log = Logger.getGlobal();
    private final ExecutorService pool;

    public FolderProcessor(ExecutorService pool){
        this.pool = pool;
    }

    void processFolder(String inputPath, String outputPath){
        File inputFolder = new File(inputPath);

        for (String filename : inputFolder.list()) {
            String filePath = inputFolder.toPath().resolve(filename).toString();
            String writeTo = new File(outputPath).toPath().resolve(filename).toString();
            if (new File(filePath).isDirectory()) {
                pool.execute(()->processFolder(filePath, writeTo));
            } else {
                pool.execute(()->{
                    log.info("Start processing " + filePath);
                    DocumentWriter.write(filePath, writeTo);
                });
            }
        }
    }
}

Note: My IDE warns me that inputFolder.list() could throw a NullPointerException if the File isn't a directory. While your current usage ensures that it is, you may want to put in a check down the line.

DocumentWriter

Since we're missing the meat of the method (the contents of the for loop), it's hard to make too many recommendations. I am concerned with the shift in naming convention (Java uses camelCase), and the lack of checking for errors in file creation. Also, you create a file and discard it as soon as you've made your checks, when you could save the FileWriter some work by passing it along.

After some cleanup:

class DocumentWriter{
    private static final Logger log = Logger.getGlobal();

    public static void write(String inputPath, String outputPath) {
        try {
            File outputFile = new File(outputPath);
            if(outputFile.getParentFile().mkdirs()){
                outputFile.createNewFile();
                FileWriter outputWriter = new FileWriter(outputFile);

                List<Document> docs = DocProcessor.processDocs(inputPath);
                for(Document doc : docs){
                    // Missing code
                }
            }else{
                // You may want to log this
                log.config("File could not be created: " + outputPath);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

DocProcessor

I assumed you wanted the typo fixed. There's not much else to say about this class, since all the logic is either tied up in a class we can't see (TextThread) or omitted. I will say that if you're running this method in parallel, you're going to be creating an ExecutorService for each invocation, possibly creating hundreds of threads. A shared ExecutorService, (could be static, but preferably a final instance variable) would be a better solution.

Other Notes

You probably want to use Executors.newWorkStealingPool(10) since it keeps the threads active while waiting for I/O operations, which will give you better performance. newFixedThreadPool(10) tends to work better for CPU-intensive operations as opposed to I/O-intensive operations.

Using a fixed-size thread pool is also problematic in case we have a many sub-directories

That is an assumption, and it is simply: wrong.

You assume that the limiting factor is the number of threads. But what makes you think so? It is more likely that other elements of this operation will limit the overall performance, such as operating respectively file system activity. To be precise: the drive system below the file system.

You see, you can't make arbitrary problems go faster just by throwing an (unlimited) number of threads at them.

If you are serious about performance, stop making assumptions. Instead, start measuring. Test how much time 1 thread needs to "process" a larger tree. Do that repeatedly (most likely file system caching will play a big role here). Then see what changes if you use a fixed thread pool.

My assumption is: you will see a certain speedup, but rather quickly, adding more threads will slow down things again. Guessing here: a pool with 4, max 8 threads might give you "optimal" results.

Implementation wise, you could put "new" subdirectories that require crawling on a queue, and then your worker threads take them from the queue for processing.

Check for new files, process them, rinse, and repeat:

while (true) {
    File[] files = new File(DIRECTORY_PATH).listFiles();
    for (File file : files) {
        /* do something with this file */

        //and delete it when finished
        file.delete();
    }

    //Pause for a second before checking again
    Thread.sleep(1000);
}

It should be possible to call the executable with a specific working directory using Runtime.exec(String command, String[] envp, File dir)

as follows:

Process process2=Runtime.getRuntime().exec("/data/data/my-package/files/myfile",
        null, new File("/data/data/my-package/files"));

maybe without the full path to myfile

Process process2=Runtime.getRuntime().exec("myfile",
        null, new File("/data/data/my-package/files"));

Context#getFilesDir() instead of hardcoding the path should work too and is safer / cleaner than specifying the path yourself since it is not guaranteed that /data/data/.. is always the correct path for all devices.

Process process2=Runtime.getRuntime().exec("myfile",
        null, getFilesDir()));

The problem with cd somewhere is that the directory is changed for a different Process so the second call to exec in a new Process does not see the change.

Are you looking for something like this?

System.out.println("Current working directory: " + System.getProperty("user.dir"));
System.out.println("Changing working directory...");
// changing the current working directory
System.setProperty("user.dir", System.getProperty("user.dir") + "/test/");

// print the new working directory path
System.out.println("Current working directory: " + System.getProperty("user.dir"));

// create a new file in the current working directory
File file = new File(System.getProperty("user.dir"), "test.txt");

if (file.createNewFile()) {
    System.out.println("File is created at " + file.getCanonicalPath());
} else {
    System.out.println("File already exists.");
}

It outputs:

Current working directory: /Users/Wasi/NetBeansProjects/TestProject
Changing working directory...
Current working directory: /Users/Wasi/NetBeansProjects/TestProject/test/
File is created at /Users/Wasi/NetBeansProjects/TestProject/test/test.txt

As Jarrod Roberson states in his answer here:

One way would be to use the system property System.getProperty("user.dir"); this will give you "The current working directory when the properties were initialized". This is probably what you want. to find out where the java command was issued, in your case in the directory with the files to process, even though the actual .jar file might reside somewhere else on the machine. Having the directory of the actual .jar file isn't that useful in most cases.

The following will print out the current directory from where the command was invoked regardless where the .class or .jar file the .class file is in.

public class Test
{
    public static void main(final String[] args)
    {
        final String dir = System.getProperty("user.dir");
        System.out.println("current dir = " + dir);
    }
}  

if you are in /User/me/ and your .jar file containing the above code is in /opt/some/nested/dir/ the command java -jar /opt/some/nested/dir/test.jar Test will output current dir = /User/me.

You should also as a bonus look at using a good object oriented command line argument parser. I highly recommend JSAP, the Java Simple Argument Parser. This would let you use System.getProperty("user.dir") and alternatively pass in something else to over-ride the behavior. A much more maintainable solution. This would make passing in the directory to process very easy to do, and be able to fall back on user.dir if nothing was passed in.

Example : GetExecutionPath

import java.util.*;
import java.lang.*;

public class GetExecutionPath
{
  public static void main(String args[]) {
    try{
      String executionPath = System.getProperty("user.dir");
      System.out.print("Executing at =>"+executionPath.replace("\\", "/"));
    }catch (Exception e){
      System.out.println("Exception caught ="+e.getMessage());
    }
  }
}

output for the above will be like

C:\javaexamples>javac GetExecutionPath.jav

C:\javaexamples>java GetExecutionPath
Executing at =>C:/javaexamples

Assuming you can use Java 1.5 or higher, I'd recommend using ProcessBuilder instead of Runtime. It will let you easily set the working directory for the process.

final Process pr = new ProcessBuilder(
    "java",
    "-Xms512M",
    "-Xmx1024M",
    "-jar",
    "minecraft_server.jar",
    "nogui")
    .directory(new File("minecraft")) //Set the working directory to ./minecraft/
    .start();

To implement this you can use the ProcessBuilder class, here's how it would look like:

File pathToExecutable = new File( "resources/external.exe" );
ProcessBuilder builder = new ProcessBuilder( pathToExecutable.getAbsolutePath(), "-i", "input", "-o", "output");
builder.directory( new File( "resources" ).getAbsoluteFile() ); // this is where you set the root folder for the executable to run with
builder.redirectErrorStream(true);
Process process =  builder.start();

Scanner s = new Scanner(process.getInputStream());
StringBuilder text = new StringBuilder();
while (s.hasNextLine()) {
  text.append(s.nextLine());
  text.append("\n");
}
s.close();

int result = process.waitFor();

System.out.printf( "Process exited with result %d and output %s%n", result, text );

It's quite a bunch of code, but gives you even more control on how the process is going to be run.