疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

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));

  }

  }