What's wrong with my multi-threaded Matrix Mult. code? 1 thread is fastest

[harjanto]

For some reason, 1 thread performs the best. What's wrong with my implementation?

I've got an i7 with hyperthreading so 8 cores

import java.util.Random;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;


public class Matrix {	
	private int values[][];
	private int rows;
	private int columns;
	
	public Matrix(int r, int c) {
		this.rows = r;
		this.columns = c;
		this.values = new int[r][c];
	}
	
	private void randomize() {
		Random generator = new Random();
		
		for (int r = 0; r < this.rows; r++) {
			for (int c = 0; c < this.columns; c++) {
				this.values[r][c] = generator.nextInt(10);
			}
		}
	}
	
	public String toString() {
		String out = "";
		for (int r = 0; r < this.rows; r++) {
			for (int c = 0; c < this.columns; c++) {
				if (c == 0) out += "[";
				else out += "\t";
				out += this.values[r][c];
			}
			out += "]\n";
		}
		
		return out;
	}
	
	public boolean equals(Object obj) {
		Matrix other = (Matrix) obj;
		if (this.columns != other.columns || this.rows != other.rows)  {
			return false;
		}
		for (int r = 0; r < this.rows; r++) {
			for (int c = 0; c < this.columns; c++) {
				if (this.values[r][c] != other.values[r][c]) {
					return false;
				}
			}
		}
		
		return true;
	}
	
	// matrix multiplication using single thread
	public Matrix times(Matrix other) {
		assert(this.columns == other.rows);
		Matrix out = new Matrix(this.rows, other.columns);
		
		for (int r = 0; r < this.rows; r++) {
			for (int c = 0; c < other.columns; c++) {
				int dotProduct = 0;
				for (int z = 0; z < this.columns; z++) {
					dotProduct += this.values[r][z] * other.values[z][c];
				}
				out.values[r][c] = dotProduct;
			}
		}
		
		return out;
	}
	
	
	
	
	
	
	
	
	// matrix multiplication with many threads
	public Matrix ptimes(Matrix other, int numberOfThreads) throws InterruptedException { // parallel
		assert(this.columns == other.rows);
		Matrix out = new Matrix(this.rows, other.columns);
		
		
		ExecutorService threadExecutor = Executors.newFixedThreadPool(numberOfThreads);
		
		for (int r = 0; r < this.rows; r++) {
			for (int c = 0; c < other.columns; c++) {
				threadExecutor.execute(new HelperThread(r, c, this, other, out));
			}
		}
		
		
		threadExecutor.shutdown();
		threadExecutor.awaitTermination(2, TimeUnit.DAYS);
		
		return out;
	}
	
	private class HelperThread implements Runnable {
		private int row;
		private int col;
		private Matrix a;
		private Matrix b;
		private Matrix out;
		
		HelperThread(int r, int c, Matrix a, Matrix b, Matrix o) {
			this.row = r;
			this.col = c;
			this.a = a;
			this.b = b;
			this.out = o;
		}
		
		public void run() {
			int dotProduct = 0;
			
			for (int z = 0; z < a.columns; z++) {
				dotProduct += this.a.values[row][z] * this.b.values[z][col];
			}
			this.out.values[row][col] = dotProduct;
		}
	}
	
	
	
	
	public static void main(String[] args) throws InterruptedException {
		int size = 100;
		
		Matrix a = new Matrix(size, size);
		a.randomize();	
		
		Matrix b = new Matrix(size, size);
		b.randomize();
		
		
		for (int t = 1; t < 15; t++) {
			long start = new Date().getTime();
			System.out.print(t + " threads: ");
			
			Matrix c = a.ptimes(b, t);
			//System.out.println(c);
	
			long finish = new Date().getTime();
			System.out.println((finish - start) + " milliseconds");
			
			Matrix d = a.times(b);
			assert(c.equals(d));
		}
	}
}