并行计算----5种方式实现判断是不是素数.Net,Win32,JavaRunnable,OpenMp,JavaThread

JAVA Thread

一、java thread判断一个数是不是素数、

二、详细说明：

素数判断：用试除法判断一个自然数a是不是质数时，用各个质数从小到大依次去除a，如果到某一个质数正好整除，这个a就可以断定不是质数；如果不能整除，当不完全商又小于这个质数时，就不必再继续试除，可以断定a必然是质数．

三、程序说明：

本程序采用的java thread，创建了两个线程同时对该数是不是素数进行判断，第一个线程用来判断从1到根号（该数）的范围内的奇数能不能整除，如果能的话就是非素数。第二个线程判断从2到根号（该数）的范围内的偶数能不能整除，如果能的话就是非素数，如果不能则是素数。

四、程序代码

 

[java]  view plain  copy

1. public class WyThread extends Thread {  
2.     private int i;  
3.     private int num;  
4.     private int flag=0;  
5.       
6.     public int getI() {  
7.         return i;  
8.     }  
9.     public void setI(int i) {  
10.         this.i = i;  
11.     }  
12.     public int getNum() {  
13.         return num;  
14.     }  
15.     public void setNum(int num) {  
16.         this.num = num;  
17.     }  
18.     public int getFlag() {  
19.         return flag;  
20.     }  
21.     public void setFlag(int flag) {  
22.         this.flag = flag;  
23.     }  
24.     public WyThread(int i,int num)  
25.     {  
26.         this.i=i;  
27.         this.num=num;  
28.     }  
29.     public void run()  
30.     {  
31.         for(;i<num;i+=2)  
32.         {  
33.               
34.            if (flag == 0)   
35.                 {   
36.                     if (num % i == 0 && i != 1)   
37.                         flag = 1;   
38.                 }   
39.            else   
40.               break;   
41.   
42.         }  
43.     }  
44.     public static void main(String[] args) throws InterruptedException  
45.     {  
46.         long c=92331323;  
47.         int m=(int)Math.sqrt(c);  
48.         WyThread wy1=new WyThread(1,m);  
49.         WyThread wy2=new WyThread(2,m);  
50.         long startTime1=System.currentTimeMillis();  
51.         wy1.start();  
52.         wy2.start();  
53.         wy1.join();  
54.         wy2.join();  
55.         long endTime1=System.currentTimeMillis();  
56.         if(wy1.getFlag()==0&&wy2.getFlag()==0)  
57.             System.out.println(c+"是素数");  
58.         else   
59.             System.out.println(c+"不是素数！");  
60.         System.out.println(endTime1-startTime1);  
61.         int flag=0;  
62.         long startTime2=System.currentTimeMillis();  
63.         for(int i=1;i<m;i++)  
64.         {  
65.             if (flag == 0)   
66.                 {   
67.                     if (c % i == 0 && i != 1)   
68.                         flag = 1;   
69.                 }   
70.            else   
71.               break;   
72.         }  
73.         if(flag==0)  
74.             System.out.println(c+"是素数");  
75.         else   
76.             System.out.println(c+"不是素数！");  
77.         long endTime2=System.currentTimeMillis();  
78.         System.out.println(endTime2-startTime2);  
79.         System.out.println((endTime2-startTime2)/(endTime1-startTime1));  
80.     }  
81. }  

OpenMp

一、openMp判断一个数是不是素数、

二、详细说明：

素数判断：用试除法判断一个自然数a是不是质数时，用各个质数从小到大依次去除a，如果到某一个质数正好整除，这个a就可以断定不是质数；如果不能整除，当不完全商又小于这个质数时，就不必再继续试除，可以断定a必然是质数．

三、程序说明：

本程序采用的openMp，采用的是parallel for循环的形式进行判断的

 

四、程序代码

[java]  view plain  copy

1. // OpenMp.cpp : 定义控制台应用程序的入口点。  
2. //  
3.   
4. #include "stdafx.h"  
5. #include "omp.h"  
6. #include <iostream>  
7. #include <math.h>  
8. using namespace std;  
9.   
10. int _tmain(int argc, _TCHAR* argv[])  
11. {  
12.     int m;   
13.     float c;   
14.     cin>>c;  
15.     int flag=0;   
16.     int c2;   
17.     m=(int)sqrt(c);   
18.     #pragma omp parallel  
19.     {  
20.         #pragma omp parallel for  
21.         for(int i=1;i<=m;i+=2)   
22.         {   
23.             if(flag==0)   
24.             {   
25.                 if(c2%i==0&&i!=1)   
26.                     flag=1;   
27.             }   
28.             else   
29.                 continue;  
30.         }   
31.         #pragma omp parallel for  
32.         for(int i=2;i<=m;i+=2)   
33.         {   
34.             if(flag==0)   
35.             {   
36.                 if(c2%i==0)   
37.                     flag=1;   
38.             }   
39.             else   
40.                 continue;  
41.         }   
42.     }  
43.     if(flag==0)   
44.         cout<<c<<"是素数"<<endl;   
45.     else   
46.         cout<<c<<"不是素数"<<endl;  
47.   
48.     return 0;  
49. }  

Java Runnable

一、JavaRunnable判断一个数是不是素数、

二、详细说明：

素数判断：用试除法判断一个自然数a是不是质数时，用各个质数从小到大依次去除a，如果到某一个质数正好整除，这个a就可以断定不是质数；如果不能整除，当不完全商又小于这个质数时，就不必再继续试除，可以断定a必然是质数．

三、程序说明：

本程序采用的javaRunnable，创建了两个线程同时对该数是不是素数进行判断，第一个线程用来判断从1到根号（该数）的范围内的奇数能不能整除，如果能的话就是非素数。第二个线程判断从2到根号（该数）的范围内的偶数能不能整除，如果能的话就是非素数，如果不能则是素数。

四、程序代码

[java]  view plain  copy

1. public class RunnableSuShu implements Runnable  
2. {  
3.   
4.     private int i;  
5.     private int num;  
6.     private int flag=0;  
7.     public int getFlag() {  
8.         return flag;  
9.     }  
10.     public RunnableSuShu(int i,int num)  
11.     {  
12.         this.i=i;  
13.         this.num=num;  
14.     }  
15.     @Override  
16.     public void run() {  
17.         // TODO Auto-generated method stub  
18.         for(;i<num;i+=2)  
19.         {  
20.               
21.            if (flag == 0)   
22.                 {   
23.                     if (num % i == 0 && i != 1)   
24.                         flag = 1;   
25.                 }   
26.            else   
27.               break;   
28.   
29.         }  
30.     }  
31.   
32. }  
33.   
34. public class ThreadWy {  
35.     public static void main(String[] args) {  
36.         long c=92331323;  
37.         int m=(int)Math.sqrt(c);  
38.         RunnableSuShu wy1=new RunnableSuShu(1, m);  
39.         RunnableSuShu wy2=new RunnableSuShu(2, m);  
40.         long startTime1=System.currentTimeMillis();  
41.         wy1.run();  
42.         wy2.run();  
43.         long endTime1=System.currentTimeMillis();  
44.         if(wy1.getFlag()==0&&wy2.getFlag()==0)  
45.             System.out.println(c+"是素数");  
46.         else   
47.             System.out.println(c+"不是素数！");  
48.         System.out.println(endTime1-startTime1);  
49.         int flag=0;  
50.         long startTime2=System.currentTimeMillis();  
51.         for(int i=1;i<m;i++)  
52.         {  
53.             if (flag == 0)   
54.                 {   
55.                     if (c % i == 0 && i != 1)   
56.                         flag = 1;   
57.                 }   
58.            else   
59.               break;   
60.         }  
61.         if(flag==0)  
62.             System.out.println(c+"是素数");  
63.         else   
64.             System.out.println(c+"不是素数！");  
65.         long endTime2=System.currentTimeMillis();  
66.         System.out.println(endTime2-startTime2);  
67.         System.out.println((endTime2-startTime2)/(endTime1-startTime1));  
68.     }  
69. }  

Win32

一、Win32API判断一个数是不是素数、

二、详细说明：

素数判断：用试除法判断一个自然数a是不是质数时，用各个质数从小到大依次去除a，如果到某一个质数正好整除，这个a就可以断定不是质数；如果不能整除，当不完全商又小于这个质数时，就不必再继续试除，可以断定a必然是质数．

三、程序说明：

本程序采用的Win32API，创建了两个线程同时对该数是不是素数进行判断，第一个线程用来判断从1到根号（该数）的范围内的奇数能不能整除，如果能的话就是非素数。第二个线程判断从2到根号（该数）的范围内的偶数能不能整除，如果能的话就是非素数，如果不能则是素数。

四、程序代码

[plain]  view plain  copy

1. #include "stdafx.h"   
2. #include <windows.h>   
3. #include <process.h>   
4. #include <math.h>   
5. #include <iostream>   
6. #include <fstream>   
7. using namespace std;   
8. int m;   
9. float c;   
10. int flag=0;   
11. int c2;   
12. HANDLE Thread1,Thread2;   
13. void StartThread1(LPVOID param)   
14. {   
15.     for(int i=1;i<=m;i+=2)   
16.     {   
17.         if(flag==0)   
18.         {   
19.             if(c2%i==0&&i!=1)   
20.                 flag=1;   
21.         }   
22.         else   
23.             break;   
24.     }   
25. }   
26.    
27. void StartThread2(LPVOID param)   
28. {   
29.     for(int j=2;j<=m;j+=2)   
30.     {   
31.         if(flag==0)   
32.         {   
33.             if(c2%j==0)   
34.                 flag=1;   
35.         }   
36.         else   
37.             break;   
38.     }   
39. }   
40.    
41.    
42. int _tmain(int argc, _TCHAR* argv[])   
43. {   
44.     cin>>c;   
45.     m=sqrt(c);   
46.     c2=(int)c;   
47.     Thread1=CreateEvent(NULL,FALSE,FALSE,NULL);   
48.     //cout<<"1"<<endl;   
49.     Thread2=CreateEvent(NULL,FALSE,FALSE,NULL);   
50.     //cout<<"2"<<endl;   
51.     _beginthread(StartThread1,0,NULL);   
52.     //cout<<"3"<<endl;   
53.     _beginthread(StartThread2,0,NULL);   
54.     //cout<<"4"<<endl;   
55.     //WaitForSingleObject(Thread2,INFINITE);   
56.     cout<<"5"<<endl;   
57.     if(flag==0)   
58.         cout<<"是素数"<<endl;   
59.     else   
60.         cout<<"不是素数"<<endl;   
61.     cin>>c;//保留输出框   
62.     return 0;   
63. }   

.NET

一、.NET判断一个数是不是素数、

二、详细说明：

素数判断：用试除法判断一个自然数a是不是质数时，用各个质数从小到大依次去除a，如果到某一个质数正好整除，这个a就可以断定不是质数；如果不能整除，当不完全商又小于这个质数时，就不必再继续试除，可以断定a必然是质数．

三、程序说明：

本程序采用的.NET，创建了两个线程同时对该数是不是素数进行判断，第一个线程用来判断从1到根号（该数）的范围内的奇数能不能整除，如果能的话就是非素数。第二个线程判断从2到根号（该数）的范围内的偶数能不能整除，如果能的话就是非素数，如果不能则是素数。

四、程序代码

[plain]  view plain  copy

1. /*   
2.     .NET并行判断一个数是不是素数   
3.  */   
4.    
5. using System;  
6. using System.Collections.Generic;  
7. using System.Linq;  
8. using System.Text;  
9. using System.Threading;  
10. namespace DotNetWyYt  
11. {  
12.     class Program  
13.     {  
14.         public static int m;  
15.         public static int c;  
16.         public static int flag = 0;  
17.         public static int c2;  
18.         public static void WithDraw1()  
19.         {  
20.             for (int i = 1; i <= m; i += 2)  
21.             {  
22.                 if (flag == 0)  
23.                 {  
24.                     if (c2 % i == 0 && i != 1)  
25.                         flag = 1;  
26.                 }  
27.                 else  
28.                     break;  
29.             }  
30.         }  
31.         public static void WithDraw2()  
32.         {  
33.             for (int j = 2; j <= m; j += 2)  
34.             {  
35.                 if (flag == 0)  
36.                 {  
37.                     if (c2 % j == 0)  
38.                         flag = 1;  
39.                 }  
40.                 else  
41.                     break;  
42.             }  
43.         }  
44.         static void Main(string[] args)  
45.         {  
46.             c = 12323;  
47.             m = (Int32)Math.Sqrt((double)c);  
48.             c2 = (int)c;  
49.             DateTime d1 = new DateTime();  
50.             ThreadStart thread1 = new ThreadStart(WithDraw1);  
51.             Thread newThread1 = new Thread(thread1);  
52.             ThreadStart thread2 = new ThreadStart(WithDraw2);  
53.             Thread newThread2 = new Thread(thread2);  
54.              
55.             newThread1.Start();  
56.             newThread2.Start();  
57.             DateTime d2 = new DateTime();  
58.             Console.WriteLine(d2-d1);  
59.             if (flag == 0)  
60.                 Console.WriteLine(c+"是素数");  
61.             else  
62.                 Console.WriteLine(c+"23不是素数");  
63.             Console.Read();  
64.         }  
65.     }  
66. }