线程不会比没有线程版本快多少

Question

I know there are other questions like that but I'm a beginner and most of the code and questions were quite complicated. Thats why I keep it as simple as possible. I come from an R background but recently I wanted to learn more about Java threads. I run through several tutorial on the topic and most of it boils down to the code I posted below. Note the code is not doing much and I made it quite inefficient so the threads would run a few seconds. The main thing to notice is that on my machine the threads run not much faster than the none threaded run. With low values in the for loop in the run method even sometimes slower. It could be because of my crappy hardware (only two cores), and that with more cores one would see the threads go faster than the non parallel version. I don't know. But what puzzles me most is that when I look at the System monitor while the program is running in both runs (parallel and non parallel) both cores are used but in the parallel version they run at nearly 100 % and in non parallel both run at 50 - 60 %. Considering that both finish at the same time the parallel version is a lot more inefficient because it uses more computer power for doing the same job not even faster. To put it in the nutshell. What am I doing wrong? I thought I wrote the the program not much different than in the Java tutorial. I posted the link below. I run linux ubuntu with the sun version of java.

http://www.java2s.com/Tutorial/Java/0160__Thread/0020__Create-Thread.htm

import java.util.ArrayList;

public class Main { 
    public static void main(String[] args) {
        ArrayList<PermutateWord> words = new ArrayList<PermutateWord>();
        System.out.println(Runtime.getRuntime().availableProcessors());
        for(int i = 0; i < Runtime.getRuntime().availableProcessors();i++){
            words.add(new PermutateWord("Christoph"));
        }
        System.out.println("Run as thread");
        long d = System.currentTimeMillis();
        for (PermutateWord w : words) {
            w.start();
        }
        for (PermutateWord w : words) {
            try {
                w.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (PermutateWord w : words) {
            System.out.println(w.getWord());
        }
        System.out.println(((double)(System.currentTimeMillis()-d))/1000+"\n");
        System.out.println("No thread");
        d = System.currentTimeMillis();
        for (PermutateWord w : words) {
            w.run();
        }
        for (PermutateWord w : words) {
            System.out.println(w.getWord());
        }
        System.out.println(((double)(System.currentTimeMillis()-d))/1000+"\n");
    }
}
class PermutateWord extends Thread {    
    private String word;
    public PermutateWord (String word){
        this.word = word;
    }
    public void run() {
        java.util.Random rand = new java.util.Random();
        for(int i = 0; i <8000000;i++){
            word = swap(word,rand.nextInt(word.length()), rand.nextInt(word.length()));
        }
    }
    private String swap(String word2, int r1, int r2) {
        char[] wordArray = word2.toCharArray();
        char c = wordArray[r1];
        wordArray[r1] = wordArray[r2];
        wordArray[r2] = c;
        return new String(wordArray);
    }
    public String getWord(){
        return word;
    }
}

Thanks in advance

Christoph

Answer 1

Most of the time is spend allocating and dealocating temporary strings, which has to be synchronized. The work that can be done in parallel is trivial and multiple threads won't give you much gain.

Math.random() also has to be synchronized. You will have better results creating local java.util.Random for each thread.

java.util.Random rand = new java.util.Random();

public void run() {
    for(int i = 0; i <8000000;i++){
        word = swap(word,rand.nextInt(word.length()), rand.nextInt(word.length()));
    }
}

But, you should really focus on optimizing swap function. I'm not sure, if it does what you want, but I'm sure it's very inefficient. + is expensive operation on String s. For every + JVM has to allocate new String which is slow and doesn't work well with multiple threads. If you just want to swap two characters, consider using char[] instead of String . It should be much easier and much faster.

edit:

private String swap(String word2, int r1, int r2) {
    char[] wordArray = word2.toCharArray();
    char c = wordArray[r1];
    wordArray[r1] = wordArray[r2];
    wordArray[r2] = c;
    return new String(wordArray);
}

This is much better. However, you are still doing 2 allocations. toCharArray() and new String both allocate memory. Because rest of your program is very simple, those two allocations take 90% of your execution time.

Answer 2

I got a lot of mileage out of putting a Thread.sleep(1000) in the join loop. Empirically, java.util.Random.nextFloat() only bought me 10%.

Even then, both parts ran in 16 seconds on an 8-core machine, suggesting it's serializing due to the synchronizations mentioned above. But good, grief, without the sleep it was running 10x slower.