并行计算----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.     }  

你可能感兴趣的:(并行计算----5种方式实现判断是不是素数.Net,Win32,JavaRunnable,OpenMp,JavaThread)