Java多线程效率-素数计算 - 第2页 - Java - Chinaunix

方兆国 发表于 2013-07-19 13:59

下面是经过优化的Java多线程运行的结果，线程数从1-39
JavaPure 1Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 27.441059013 s

JavaPure 2Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 15.002512164 s

JavaPure 3Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 14.666844501 s

JavaPure 4Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.94517485 s

JavaPure 5Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.898218614 s

JavaPure 6Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.920853457 s

JavaPure 7Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 11.044363006 s

JavaPure 8Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.770187893 s

JavaPure 9Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.744386465 s

JavaPure 10Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.678533515 s

JavaPure 11Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.672157318 s

JavaPure 12Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.654416373 s

JavaPure 13Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.673098418 s

JavaPure 14Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.874618216 s

JavaPure 15Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.919771963 s

JavaPure 16Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.735419301 s

JavaPure 17Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.700124453 s

JavaPure 18Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.784798483 s

JavaPure 19Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.903189502 s

JavaPure 20Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.721297829 s

JavaPure 21Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.691479292 s

JavaPure 22Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.649655172 s

JavaPure 23Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.646989932 s

JavaPure 24Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.739623451 s

JavaPure 25Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.714967826 s

JavaPure 26Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.703481252 s

JavaPure 27Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.658188017 s

JavaPure 28Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.696676172 s

JavaPure 29Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.730198419 s

JavaPure 30Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.634209912 s

JavaPure 31Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.650298271 s

JavaPure 32Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.652929998 s

JavaPure 33Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.662882191 s

JavaPure 34Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.700259414 s

JavaPure 35Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.700409772 s

JavaPure 36Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.724275562 s

JavaPure 37Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.705531019 s

JavaPure 38Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.709783176 s

JavaPure 39Mix线程实现：
Number of primes under 10000000 is664579
Time taken is 10.645592322 s

方兆国 发表于 2013-07-19 14:02

不过十经过优化的还是没有经过优化的，制造的线程数超过CPU可以执行的线程数后，程序的效率变化不是很大，趋于一个稳定的值，线程之间切换造成的性能损失也不明显
。

经过优化的类和没有经过优化的运行效率差别不是很大，仅仅不到0.5s左右的差别

方兆国 发表于 2013-07-19 17:42

用C语言和C++试了一下这个例子,发现C语言和C++完全玩爆Java

方兆国 发表于 2013-07-19 17:44

C语言单线程版#include <stdio.h>
#include <time.h>

int main(int argc, char *argv[]) {
time_t start, end;
time(&start);
int sum = countPrime(10000000);
time(&end);
printf("0-10000000之间有%ld个素数\n", sum);
printf("程序运行时间%d秒\n", end - start);
return 0;
}

#include <math.h>

int isPrime(long number) {
if (1 >= number) {
return 0;
}
long i;
for (i = 2; i <= sqrt(number); i++) {
if (0 == number % i) {
return 0;
}
}
return 1;
}

int countPrime(long number) {
int total = 0;
long i;
for (i = 2; i < number; i++) {
if (isPrime(i)) {
total++;
}
}
return total;
}
运行结果0-10000000之间有664579个素数
程序运行时间9秒

方兆国 发表于 2013-07-19 17:45

本帖最后由方兆国于 2013-07-19 17:46 编辑

#include <stdio.h>
#include <time.h>

int main(int argc, char *argv[]) {
time_t start, end;
time(&start);
int sum = countPrime(10000000);
time(&end);
printf("0-10000000之间有%ld个素数\n", sum);
printf("程序运行时间%d秒\n", end - start);
return 0;
}

/*
* ConcurrentPrimeFinder.c
*
*Created on: 2013年7月19日
* Author: root
*/

#include <pthread.h>
#include <stdio.h>
#include <malloc.h>
#include <math.h>

typedef struct {
int id;
long lower;
long upper;
int total;
} Message;

int flag = { 0, 0, 0, 0 };

int isPrime(long number) {
if (1 >= number) {
return 0;
}
long i;
for (i = 2; i <= sqrt(number); i++) {
if (0 == number % i) {
return 0;
}
}
return 1;
}

void *countPrimeInRange(void* mess) {
long i = 0;
Message* message = (Message*) mess;
for (i = message->lower; i < message->upper; i++) {
if (isPrime(i)) {
message->total++;
}
}
flag = 1;
return NULL;
}

int countPrime(long number) {
int total = 0;
pthread_t thread;
Message *message;
long start = 0, end = 0;
long range = number / 4;
int volatile i = 0;
for (i = 0; i < 4; i++) {
message = (Message*) malloc(sizeof(Message));
}
for (i = 0; i < 4; i++) {
start = range * i;
if (i < 3) {
end = start + range;
} else {
end = number;
}
message->id = i;
message->lower = start;
message->upper = end;
message->total = 0;
pthread_create(&thread, NULL, countPrimeInRange,
(void*) (message));
}
i = 0;
while (i < 4) {
if (1 == flag) {
total += message->total;
i++;
}
}
return total;
}
运行结果0-10000000之间有664579个素数
程序运行时间5秒

方兆国 发表于 2013-07-19 17:49

/*
* Main.c
*
*Created on: 2013年7月19日
*    Author: root
*/

#include "ConcurrentPrimeFinder.h"

#include <stdio.h>
#include <time.h>

int main(int argc, char *argv[]) {
time_t start, end;
ConcurrentPrimeFinder finder;
time(&start);
int sum = finder.countPrime(10000000);
time(&end);
printf("0-10000000之间有%ld个素数\n", sum);
printf("程序运行时间%d秒\n", end - start);
return 0;
}
/*
* ConcurrentPrimeFinder.h
*
*Created on: 2013年7月19日
*    Author: root
*/

#ifndef CONCURRENTPRIMEFINDER_H_
#define CONCURRENTPRIMEFINDER_H_

#include <boost/thread.hpp>
#include <stdio.h>

class ConcurrentPrimeFinder {
public:
ConcurrentPrimeFinder();
virtual ~ConcurrentPrimeFinder();
int countPrime(long number);

private:
int poolsize;
};

#endif /* CONCURRENTPRIMEFINDER_H_ */
/*
* ConcurrentPrimeFinder.cpp
*
*Created on: 2013年7月19日
*    Author: root
*/

#include "ConcurrentPrimeFinder.h"

ConcurrentPrimeFinder::ConcurrentPrimeFinder() {
poolsize = 4;

}

ConcurrentPrimeFinder::~ConcurrentPrimeFinder() {
}

bool isPrime(long number) {
if (1 >= number) {
return false;
}
long i;
for (i = 2; i <= sqrt(number); i++) {
if (0 == number % i) {
return false;
}
}
return true;
}

void countPrimeInRange(long int lower, long int upper, int *total, bool *flag) {
long i = 0;
for (i = lower; i < upper; i++) {
if (isPrime(i)) {
(*total)++;
}
}
*flag = true;
}

int ConcurrentPrimeFinder::countPrime(long number) {
using namespace boost;
int total = 0, sum = { 0 };
bool flag = { false };
long start = 0, end = 0;
long range = number / poolsize;
int volatile i = 0;
for (i = 0; i < poolsize; i++) {
start = range * i;
if (i < poolsize - 1) {
end = start + range;
} else {
end = number;
}
thread mythread(
bind(&countPrimeInRange, start, end, &(sum), &(flag)));
}
i = 0;
while (i < poolsize) {
if (flag) {
total += sum;
i++;
}
}
return total;
}
运行结果0-10000000之间有664579个素数
程序运行时间5秒

pitonas 发表于 2013-07-26 15:24

0-10000000之间有664579个素数
程序运行时间5秒 5秒:victory:

方兆国 发表于 2013-07-26 18:34

pitonas 发表于 2013-07-26 15:24 static/image/common/back.gif
5秒

你的电脑能运行几秒

pitonas 发表于 2013-07-29 09:44

方兆国发表于 2013-07-26 11:34 static/image/common/back.gif
你的电脑能运行几秒我感觉我的电脑真是slow啊！ :emn16::emn16:

方兆国 发表于 2013-07-30 09:01

换台新电脑吧~\(≧▽≦)/~

页: 1 [2]

Chinaunix's Archiver