java Multithreading (newCachedThreadPool ), then writing result to one file?

I have tried to do this with simple Threads and succeded but I believe that using Threadpool I could do the same thing more effeciently:)? simple threads:

public static class getLogFile implements Runnable {
    private String file;

    public void setFilename(String namefile){
    file=namefile;
    }
    public int run1(String Filenamet) {

    connectToServer(XXX, Filenamet, XXX, XXX, XXX, XXX);//creates a file and downloads it

        return 0;
    }

    public void run() {
            run1(file);
    }

}

in main:
for(x=0 ; x < 36 ; x++){
    String Filename1=Filename+x;
    getLogFile n=new getLogFile();
    n.setFilename(Filename1);
    (new Thread(n))开发者_开发问答.start();

}

Program connects to the server executes 36 commands(using threadpool/simplethreads?!) at the same time and either downloads 36 result files, than merges them, or maybe it could just write to one file on server and then download it?

1. how to transform this code into threadpools?
2. how to write data to one file from 36 threads?

I can only offer you directions.

In order to use thread pool, look how ServiceExecutor works. Any example from Google will give you enough information. As an example look at: http://www.deitel.com/articles/java_tutorials/20051126/JavaMultithreading_Tutorial_Part4.html

Concerning writing 36 threads to its own file, or writing into the one file. I cannot say anything about writing by several threads into the same file, but you may use CyclicBarrier to wait event when all threads will finish writing. Example of its using you may find here: http://download.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/CyclicBarrier.html

It's not clear what you want to do. My thoughts are that creating 36 separate connections to the server will be a sizable load that it could well do without.

Can the server assemble these 36 files itself and look after the threading itself ? That seems a more logical partition of duties. The server would have knowledge of how parallelisable this work is, and there's a substantial impact on the server of servicing multiple connections (including potentially blocking out other clients).

A simple way to do it using java task executors, as follows:

ExecutorService executor = Executors.newFixedThreadPool(100);
for(int i=0;i<100;i++)
{
    executor.execute(new Runnable(i));
}

You can also use spring task executors, it will be easier. However, I will also suggest using a single connection, as mentioned above.