Java单多线程算法相比较

1进程和线程的概念

　　1.1什么是进程

　　一个进程就是在一个运行的程序,它有自己独立的内存空间,一组系统资源,每个进程的内部数据和状态都是独立的,例如在window是同时打开多个记事本,虽然它们所运行的程序代码都是一样的,但是所使用的内存空间是独立的,互不干扰.

　　1.2什么是线程

　　线程与进程相似,是一段完成某个特定功能的代码,是程序中单个顺序的流控制;但与进程不同的是,同类的多个线程共享一块内存空间和一组系统资源,而线程本身的数据通常只有微处理器的寄存器数据,以及一个供程序执行时使用的堆栈

　　1.3进程与线程的区别

　　1. 进程:每个进程都有独立的代码和数据空间(进程上下文) ,进程切换的开销大.

　　2. 线程:轻量的进程,同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换的开销小.

　　3. 多进程:在操作系统中,能同时运行多个任务程序.

　　4. 多线程:在同一应用程序中,有多个顺序流同时执行.

　　1.4线程创建的两种方式

　　采用继承Thread类创建线程

　　该方法比较简单,主要是通过继承java.lang.Thread类,并覆盖Thread类的run()方法来完成线成的创建.Thread 类是一个具体的类,即不是抽象类,该类封装了线程的行为.要创建一个线程,程序员必须创建一个从 Thread 类导出的新类.Thread类中有两个最重要的函数run()和start().

　　通过实现Runnable接口创建线程

　　该方法通过生成实现java.lang.Runnable接口的类.该接口只定义了一个方法run(),所以必须在新类中实现它.但是 Runnable 接口并没有任何对线程的支持,我们还必须创建 Thread 类的实例,这一点通过 Thread 类的构造函数

　　public Thread(Runnable target);来实现.

　　2 单线程和多线程性能比较

　　以使用蒙特卡罗概率算法求π为例,进行单线程和多线程时间比较

　　2.1什么是蒙特卡罗概率算法

　　蒙特卡罗法(Monte Carlo method)是以概率和统计的理论、方法为基础的一种计算方法,将所求解的问题同一定的概率模型相联系,用电子计算机实现统计模拟或抽样,以获得问题的近似解,故又称统计模拟法或统计试验法. --百度百科

　　蒙特卡罗求算法求π

　　第一步

　　画正方形和内切圆

　　第二步

　　变换表达式

　　正方形面积As=(2R)^2

　　圆的面积Ac=πR^2

　　Ac/As=(2R)^2/πR^2

　　π=4As/Ac

　　令P=As/Sc,则π=4P

　　第三步

　　重复N次实验求平均值

　　在正方形区域内随机生成一个点A,若A落在圆区域内,M++

　　P=M/N

　　π=4P,N的取值越大,π的值越精确

 

　　2.2 java代码实现算法

　　N取值为10000万,多线程的数为100,每个线程执行100万次模拟实验

　　线程实现

　　import java.util.concurrent.CountDownLatch;

　　public class ProModel implements Runnable {

　　public int N;//随机实验的总次数

　　public static int M;//随机点落在圆中的次数

　　private int id;

　　private final CountDownLatch doneSignal;

　　OBJ semaphore;

　　public ProModel(int id,CountDownLatch doneSignal,int N,OBJ semaphore2){

　　this.id=id;

　　this.doneSignal=doneSignal;

　　this.N=N;

　　this.semaphore=semaphore2;

　　M=0;

　　}

　　public void run(){

　　int tempM=0;

　　for(int i=0;i

　　if(isInCircle()){

　　tempM++;

　　}

　　}

　　synchronized (semaphore) {

　　add(tempM);

　　}

　　doneSignal.countDown();//使end状态减1

　　}

　　public void add(int tempM){

　　System.out.println(Thread.currentThread().getName());

　　M=M+tempM;

　　System.out.println(M);

　　}

　　//随机产生一个在正方形区域的点,判断它是否在圆中

　　public boolean isInCircle(){

　　double x=Math.random();

　　double y=Math.random();

　　if((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5)<0.25)

　　return true;

　　else

　　return false;

　　}

　　public static int getTotal(){

　　return M;

　　}

　　}

　　多线程Main实现

　　import java.util.concurrent.CountDownLatch;

　　import java.util.concurrent.ExecutorService;

　　import java.util.concurrent.Executors;

　　public class MutliThread {

　　public static void main(String[] args) throws InterruptedException {

　　long begin=System.currentTimeMillis();

　　int threadSize=100;

　　int N=1000000;

　　OBJ semaphore = new OBJ();

　　CountDownLatch doneSignal = new CountDownLatch(threadSize);

　　ProModel[] pros=new ProModel[threadSize];

　　//设置特定的线程池,大小为threadSizde

　　System.out.println(“begins!”);

　　ExecutorService exe = Executors.newFixedThreadPool(threadSize);

　　for(int i=0;i

　　exe.execute(new ProModel(i+1,doneSignal,N,semaphore));

　　try{

　　doneSignal.await(); //等待end状态变为0, }catch (InterruptedException e) {

　　// TODO: handle exception35

　　e.printStackTrace();

　　}finally{

　　System.out.println(“ends!”);

　　System.out.println(4*(float)ProModel.getTotal()/(float)(threadSize*N));

　　}

　　exe.shutdown();

　　long end=System.currentTimeMillis();

　　System.out.println(“used time(ms):”+(end-begin));

　　}

　　}

　　class OBJ{}

　　单线程Main实现

　　import java.util.concurrent.CountDownLatch;

　　import java.util.concurrent.ExecutorService;

　　import java.util.concurrent.Executors;

　　public class SingleThread {

　　public static void main(String[] args) {

　　long begin=System.currentTimeMillis();

　　int threadSize=1;

　　int N=100000000;

　　OBJ semaphore = new OBJ();

　　CountDownLatch doneSignal = new CountDownLatch(threadSize);

　　ProModel[] pros=new ProModel[threadSize];

　　//设置特定的线程池,大小为5

　　System.out.println(“begins!”);

　　ExecutorService exe = Executors.newFixedThreadPool(threadSize);

　　for(int i=0;i

　　exe.execute(new ProModel(i+1,doneSignal,N,semaphore));

　　try{

　　doneSignal.await(); //等待end状态变为0, }catch (InterruptedException e) {

　　// TODO: handle exception35

　　e.printStackTrace();

　　}finally{

　　System.out.println(“ends!”);

　　System.out.println(4*(float)ProModel.getTotal()/(float)(threadSize*N));

　　}

　　exe.shutdown();

　　long end=System.currentTimeMillis();

　　System.out.println(“used time(ms):”+(end-begin));

　　}

　　}