为什么单线程操作比无线程操作花费的时间长 3 倍?
Why does a single threaded operationg takes 3 times longer than no threaded?
我正在 Java 中测试并发性,我的 objective 是为了确定拥有多个线程是否真的有益,但是,我得到的结果并不相加。我正在尝试优化阶乘函数,对于这个特定的测试,我使用的是 1e9!我想要结果模 1e9+7 这样它就不会溢出。首先,我根据 number_of_threads 划分了数字,并分别为每个线程分配了他们的工作。然后我正常进行并比较我得到的时间。似乎当 number_of_threads = 4 时,我得到的结果比没有线程的版本更好,这是有道理的,因为我的 CPU 有 4 个内核。正如预期的那样,与仅 4 个线程相比,任何数量大于 4 的线程的时间都较慢。但是,当使用少于 4 个线程时,结果会变得很大,例如,使用 1 个线程,我希望它的持续时间与执行时相同它没有线程+开销。没有线程我得到 6.2 秒和 19.3 有 1 个线程,这对于它来说只是开销来说差异太大了。
为了测试原因,我在 运行 方法上放置了一些计数器,有时似乎只执行其中的 for 的一个循环需要超过一毫秒,而且它不应该' t 因为它只是两个操作加上计时器。
public class Calc implements Runnable{
long min, max, mod, res;
Res r;
public Calc(long min, long max, long mod, Res r) {
this.min = min;
this.max = max;
this.mod = mod;
res = 1;
this.r = r;
}
public void run() {
for(long i = min; i <= max; i++) {
res *= i;
res %= mod;
}
r.addup(res);
}
}
public class Res{
long result;
long mod;
public Res(long mod) {
result = 1;
this.mod = mod;
}
public synchronized void addup(long add) {
result *= add;
result %= mod;
}
public long getResult() {
return result;
}
}
public class Main{
public static void main(String args[]) {
long startTime = System.nanoTime();
final long factorial = 1000000000L;
final long modulo = 1000000007L;
Res res = new Res(modulo);
int number_of_threads = 1;
Thread[] c = new Thread[number_of_threads];
long min = 1, max = factorial/(long)number_of_threads;
long cant = max;
for(int i = 0; i < number_of_threads; i++) {
if((long)i < (factorial % number_of_threads))max++;
c[i] = new Thread(new Calc(min, max, modulo, res));
c[i].start();
min = max +1;
max += cant;
}
for(int i = 0; i < number_of_threads; i++) {
try {
c[i].join();
}catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(res.getResult());
long endTime = System.nanoTime();
long totalTime = endTime - startTime;
System.out.println((double)totalTime/1000000000L);
}
}
当 number_of_threads = 1 时,我得到 19.3 秒。当 number_of_threads = 2 我得到 10.1 秒。当 number_of_threads = 3 我得到 7.1 秒。当 number_of_threads = 4 我得到 5.4 秒。当没有线程时,我得到 6.2 秒(我用相同的方法计算这个时间)
只有 1 个线程和没有线程应该没有太大区别,对于 2 个和 3 个线程,它应该比没有线程快。为什么会这样,有什么办法可以解决吗?谢谢
编辑:添加无线程版本
public class Main{
public static void main(String args[]) {
long startTime = System.nanoTime();
final long factorial = 1000000000L;
final long modulo = 1000000007L;
long res = 1;
for(long i = 1; i <= factorial; i++) {
res *= i;
res %= modulo;
}
System.out.println(res);
long endTime = System.nanoTime();
long totalTime = endTime - startTime;
System.out.println((double)totalTime/1000000000L);
}
}
发生这种情况是因为您的"no thread"(仅主线程)版本使用了所有更易于优化的编译时常量。
如果您确保编译器不会提前知道这些值是什么:
class Main{
public static void main(String args[]) {
long factorial = Long.parseLong(args[0]);
long modulo = Long.parseLong(args[1]);
long startTime = System.nanoTime();
long res = 1;
for(long i = 1; i <= factorial; i++) {
res *= i;
res %= modulo;
}
System.out.println(res);
long endTime = System.nanoTime();
long totalTime = endTime - startTime;
System.out.println((double)totalTime/1000000000L);
}
}
然后会明显变慢:
$ java Main 1000000000 1000000007
698611116
11.368487148
在我的机器上,甚至比你的另一台机器的单线程情况稍微多一点:
$ java Main
698611116
10.709532315
类似地,如果您将 1 线程示例修改为使用 .run()
而不是 .start()
,主线程上的所有内容都将 运行,但不会有来自主线程的加速1 线程案例。
我正在 Java 中测试并发性,我的 objective 是为了确定拥有多个线程是否真的有益,但是,我得到的结果并不相加。我正在尝试优化阶乘函数,对于这个特定的测试,我使用的是 1e9!我想要结果模 1e9+7 这样它就不会溢出。首先,我根据 number_of_threads 划分了数字,并分别为每个线程分配了他们的工作。然后我正常进行并比较我得到的时间。似乎当 number_of_threads = 4 时,我得到的结果比没有线程的版本更好,这是有道理的,因为我的 CPU 有 4 个内核。正如预期的那样,与仅 4 个线程相比,任何数量大于 4 的线程的时间都较慢。但是,当使用少于 4 个线程时,结果会变得很大,例如,使用 1 个线程,我希望它的持续时间与执行时相同它没有线程+开销。没有线程我得到 6.2 秒和 19.3 有 1 个线程,这对于它来说只是开销来说差异太大了。
为了测试原因,我在 运行 方法上放置了一些计数器,有时似乎只执行其中的 for 的一个循环需要超过一毫秒,而且它不应该' t 因为它只是两个操作加上计时器。
public class Calc implements Runnable{
long min, max, mod, res;
Res r;
public Calc(long min, long max, long mod, Res r) {
this.min = min;
this.max = max;
this.mod = mod;
res = 1;
this.r = r;
}
public void run() {
for(long i = min; i <= max; i++) {
res *= i;
res %= mod;
}
r.addup(res);
}
}
public class Res{
long result;
long mod;
public Res(long mod) {
result = 1;
this.mod = mod;
}
public synchronized void addup(long add) {
result *= add;
result %= mod;
}
public long getResult() {
return result;
}
}
public class Main{
public static void main(String args[]) {
long startTime = System.nanoTime();
final long factorial = 1000000000L;
final long modulo = 1000000007L;
Res res = new Res(modulo);
int number_of_threads = 1;
Thread[] c = new Thread[number_of_threads];
long min = 1, max = factorial/(long)number_of_threads;
long cant = max;
for(int i = 0; i < number_of_threads; i++) {
if((long)i < (factorial % number_of_threads))max++;
c[i] = new Thread(new Calc(min, max, modulo, res));
c[i].start();
min = max +1;
max += cant;
}
for(int i = 0; i < number_of_threads; i++) {
try {
c[i].join();
}catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(res.getResult());
long endTime = System.nanoTime();
long totalTime = endTime - startTime;
System.out.println((double)totalTime/1000000000L);
}
}
当 number_of_threads = 1 时,我得到 19.3 秒。当 number_of_threads = 2 我得到 10.1 秒。当 number_of_threads = 3 我得到 7.1 秒。当 number_of_threads = 4 我得到 5.4 秒。当没有线程时,我得到 6.2 秒(我用相同的方法计算这个时间)
只有 1 个线程和没有线程应该没有太大区别,对于 2 个和 3 个线程,它应该比没有线程快。为什么会这样,有什么办法可以解决吗?谢谢
编辑:添加无线程版本
public class Main{
public static void main(String args[]) {
long startTime = System.nanoTime();
final long factorial = 1000000000L;
final long modulo = 1000000007L;
long res = 1;
for(long i = 1; i <= factorial; i++) {
res *= i;
res %= modulo;
}
System.out.println(res);
long endTime = System.nanoTime();
long totalTime = endTime - startTime;
System.out.println((double)totalTime/1000000000L);
}
}
发生这种情况是因为您的"no thread"(仅主线程)版本使用了所有更易于优化的编译时常量。
如果您确保编译器不会提前知道这些值是什么:
class Main{
public static void main(String args[]) {
long factorial = Long.parseLong(args[0]);
long modulo = Long.parseLong(args[1]);
long startTime = System.nanoTime();
long res = 1;
for(long i = 1; i <= factorial; i++) {
res *= i;
res %= modulo;
}
System.out.println(res);
long endTime = System.nanoTime();
long totalTime = endTime - startTime;
System.out.println((double)totalTime/1000000000L);
}
}
然后会明显变慢:
$ java Main 1000000000 1000000007
698611116
11.368487148
在我的机器上,甚至比你的另一台机器的单线程情况稍微多一点:
$ java Main
698611116
10.709532315
类似地,如果您将 1 线程示例修改为使用 .run()
而不是 .start()
,主线程上的所有内容都将 运行,但不会有来自主线程的加速1 线程案例。