Насколько я понимаю, я написал простую однопользовательскую и многопоточную программу ниже, чтобы проверить скорость выполнения. Но моя однопоточная программа выполняется быстрее, чем многопоточность, любезно см. Ниже программу и упоминает, что что-то не так.
Одиночная тема:
import java.util.Calendar;
public class NormalJava {
public static void main(String[] args) {
System.out.println("Single Thread");
int a = 1000;
int b = 200;
NormalJava nj = new NormalJava();
nj.Add(a, b);
nj.Sub(a, b);
nj.Mul(a, b);
nj.Div(a, b);
Calendar lCDateTime = Calendar.getInstance();
System.out.println("Calender - Time in milliseconds :"
+ lCDateTime.getTimeInMillis());
}
private void Add(int a, int b) {
System.out.println("Add :::" + (a + b));
}
private void Sub(int a, int b) {
System.out.println("Sub :::" + (a - b));
}
private void Mul(int a, int b) {
System.out.println("Mul :::" + (a * b));
}
private void Div(int a, int b) {
System.out.println("Mul :::" + (a / b));
}
}
Вывод:
Одиночная тема | Добавить: 1200
Sub: 800
Mul: 200000
Mul: 5
Calender - Время в миллисекундах: 138 415 866 7863
Многопоточная программа:
package runnableandcallable;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class MainThread {
private static ExecutorService service = Executors.newFixedThreadPool(10); // connection
// pool
@SuppressWarnings("unchecked")
public static void main(String[] args) throws InterruptedException {
System.out.println("Multithreading");
MainThread mt = new MainThread();
mt.testThread(1000, 200);
Calendar lCDateTime = Calendar.getInstance();
System.out.println("Calender - Time in milliseconds :"
+ lCDateTime.getTimeInMillis());
}
public void testThread(final int a, final int b) {
// create a callable for each method
Callable<Void> callableAdd = new Callable<Void>() {
@Override
public Void call() throws Exception {
Add(a, b);
return null;
}
};
Callable<Void> callableSub = new Callable<Void>() {
@Override
public Void call() throws Exception {
Sub(a, b);
return null;
}
};
Callable<Void> callableMul = new Callable<Void>() {
@Override
public Void call() throws Exception {
Mul(a, b);
return null;
}
};
Callable<Void> callableDiv = new Callable<Void>() {
@Override
public Void call() throws Exception {
Div(a, b);
return null;
}
};
// add to a list
List<Callable<Void>> taskList = new ArrayList<Callable<Void>>();
taskList.add(callableAdd);
taskList.add(callableSub);
taskList.add(callableMul);
taskList.add(callableDiv);
// create a pool executor with 3 threads
ExecutorService executor = Executors.newFixedThreadPool(3);
try {
// start the threads
List<Future<Void>> futureList = executor.invokeAll(taskList);
for (Future<Void> voidFuture : futureList) {
try {
// check the status of each future. get will block until the
// task
// completes or the time expires
voidFuture.get(100, TimeUnit.MILLISECONDS);
} catch (ExecutionException e) {
System.err
.println("Error executing task " + e.getMessage());
} catch (TimeoutException e) {
System.err.println("Timed out executing task"
+ e.getMessage());
}
}
} catch (InterruptedException ie) {
// do something if you care about interruption;
}
}
private void Add(int a, int b) {
System.out.println("Add :::" + (a + b));
}
private void Sub(int a, int b) {
System.out.println("Sub :::" + (a - b));
}
private void Mul(int a, int b) {
System.out.println("Multiply :::" + (a * b));
}
private void Div(int a, int b) {
System.out.println("Division :::" + (a / b));
}
}
Малитреющий вывод:
Многопоточность
Sub: 800
Отдел: 5
Добавить: 1200
Multiply: 200000
Calender - Время в миллисекундах: 138 415 868 0821
Здесь один поток выполняется на 138 415 866 7863 миллисекундах и многопоточность, выполненная на этом этапе 138 415 868 0821 миллисекунды. Тогда какова истинная цель многопоточности?