网络编程多线程实验报告(共11页).doc

《网络编程多线程实验报告(共11页).doc》由会员分享，可在线阅读，更多相关《网络编程多线程实验报告(共11页).doc（11页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、精选优质文档-倾情为你奉上 XXX 大 学 （计算机学院）网络编程技术课内实验报告实验名称： 第一、二次实验合：多线程实践 专业名称： 班 级： 学生姓名： 学号（8位）： 指导教师： 实验日期： 一. 实验目的及实验环境 1 理解线程的定义和概念 2 掌握线程的实现方案 3 掌握线程的状态 4 掌握加速比的求解二. 实验内容实验一： 1 对随机产生的1M-10M的数组进行求和，根据实验一要求采用多线程共同完成任务。 2 使用蒙特卡洛算法求PI的值，实验统计的总次数不得低于10M次，根据实验一要求采用多线程完成PI的求解； 3 下载四大名著之一红楼梦的文本全文，统计全文中“贾宝玉”和“林黛玉”

2、的出现的次数；根据实验一要求采用多线程完成上述任务。实验一要求：上述三个问题，分别用串行，1道线程，2道线程，4道线程，8道线程来完成，并统计完成实验同一样本所使用的时间，做出统计图。如果多线程的采用降低了求解的效率，是否存在为共享问题，请给出解决方案。并根据加速比的计算公式，计算并行化之后的加速比。（加速比=串行时间/并行时间）实验2： 4使用二分查查使用多线程进行求解。查找的有序数据量不少于1M。 5 对归并排序使用多线程进行求解。排序数据量不少于1M。 6 对快速排序使用多线程进行求解。排序数据量不少于1M。三 方案设计1.数组求和设计：将大数组根据线程的数量进行拆分。 ：每个线程对数组

3、的部分元素进行求和。 ：对剩余数组求和：等待所有线程执行完毕，累加和，返回结果。 2. 蒙特卡洛求PI : 开启多个线程分别用蒙特卡洛算法求解PI: 计算结果累加除以开启线程个数 (开启线程个数越多，结果越精确)3. 二分查找使用多线程：将给定1M数据量数组排序 ：将数组划分成多块 ：开启相对线程个数：每个线程对自己内部数组进行二分查找：找到返回位置，没找到等待线程全部结束 4. 多线程归并排序：将给定数组进行划分：创建线程执行归并排序：进程同步：返回有序数组5. 多线程快速排序：将需要排序的数组分成多组：对每组实现一个线程来快速排序：最后用归并排序算法的思想合并这些数组：最终实现原序列的排序

4、过程四测试数据及运行结果1.多线程数组求2.蒙特卡洛求PI4. 多线程二分查找5.多线程归并排序6.多线程快速排序五总结多线程并发实验中，解决了之前学过的一些算法，fork操作可以将一个大的问题划分为若干个较小的问题，从而在递归的过程中，到直接进行计算的粒度适合的子问题；子问题在结算后，可以得到整个问题的部分解join操作收集子结果，合并，得到完整解。这座方式对递归的应用更加灵活广泛。并且次方发法减少等待时间，此外提高性能。而之前都是串行解决，多线程并发处理会提升性能，为了让程序运行的更快。但是，并不是启动更多的线程能让程序最大限度的并发执行。有些任务，资源越多，那么就越完成的快。但是有些任务

5、本质上是串行的，即使增加再多的资源也未必能够提高速度。通过分治算法算法来解决问题，为此我借阅相关书籍了解更多内容。六 附录：源代码（电子版， 纸质版不打印）1.import java.util.Random;public class TS public static long Tsum(final int array) if (array = null | array.length = 0) throw new IllegalArgumentException(array length must greater than 0); final RuntimeData rd = new Runti

6、meData(); int threadCount = rd.getThreadCount(array); System.out.println(thread count: + threadCount); final int lenPerThread = array.length / threadCount; long s1=System.currentTimeMillis(); for (int i = 0; i threadCount; i+) final int index = i; new Thread() Override public void run() long s = 0;

7、int start = index * lenPerThread; int end = start + lenPerThread; for (int j = start; j end; j+) s += arrayj; synchronized (rd) rd.sum += s; rd.finishThreadCount+; ; .start(); int remain = array.length % threadCount; long s = 0; for (int i = array.length - remain; i array.length; i+) s += arrayi; sy

8、nchronized (rd) rd.sum += s; while (rd.finishThreadCount != threadCount) try Thread.sleep(1); catch (InterruptedException e) e.printStackTrace(); break; long s2=System.currentTimeMillis()-s1; System.out.println(多线程并发求和需要时间：+s2); return rd.sum; public static void main(String args) int arr=new int1024

9、*1024;Random r=new Random();for(int i=0;iarr.length;i+)arri=r.nextInt(1000);System.out.println(多线程并发求和：+Tsum(arr);System.out.println(单线程基本求和：+BasicCaculator.sum(arr); class RuntimeData long sum; int defThreadCount = 15; int finishThreadCount; public int getThreadCount(int array) if (array.length def

10、ThreadCount) return array.length; return defThreadCount; class BasicCaculator public static long sum(int numbers) long sum = 0; long s1=System.currentTimeMillis(); for(int i=0;inumbers.length;i+) sum += numbersi; long s2=System.currentTimeMillis()-s1; System.out.println(单线程并发求和需要时间：+s2); return sum;

11、 5.package 网络编程实验;import java.util.Random; import java.util.concurrent.CountDownLatch; public class MergeSort public static void main(String args) throws InterruptedException int length = 1024*1024; int array = new intlength; Random random = new Random(); for(int i = 0; i length; i+) int x = random.

12、nextInt(); arrayi = x; long time1 = System.currentTimeMillis(); int minLength = length/2; int a = new intminLength; int b = new intminLength; for(int i=0; i2; i+) int start = minLength * i; int end = minLength * (i + 1); if(i=0) for(int j=start, k=0; jend; j+,k+) ak = arrayj; else if(i=1) for(int j=

13、start, k=0; jend; j+,k+) bk = arrayj; CountDownLatch latch = new CountDownLatch(2); new Thread(new Runnable() Override public void run() MergeSort.sort(a); latch.countDown(); ).start(); new Thread(new Runnable() Override public void run() MergeSort.sort(b); latch.countDown(); ).start(); latch.await(

14、); merge(a, b, array); long time2 = System.currentTimeMillis(); System.out.println(归并排序时间： + (time2 - time1) + 毫秒); private static void merge(int a1, int a2, int tmpArray) int length1 = a1.length; int length2 = a2.length; int left = 0; int right = 0; int pos = 0; while(left length1 & right length2)

15、if(a1left = a2right) tmpArraypos = a1left; left+; else tmpArraypos = a2right; right+; pos+; while(left length1) tmpArray pos+ = a1 left+ ; while(right length2) tmpArray pos+ = a2 right+ ; /递归分解 public static void sort(int array) int length = array.length; int tmpArray = new int length ; sort(array,

16、tmpArray, 0, length-1); public static void sort(int array, int tmpArray, int left, int right) if(left right) int center = (left + right)/2; sort(array, tmpArray, left, center); sort(array, tmpArray, center+1, right); merge(array, tmpArray, left, center+1, right); /合并排序 private static void merge(int

17、array, int tmpArray, int leftStart, int rightStart, int rightEnd) int leftEnd = rightStart - 1; int tmpPos = leftStart; int total = rightEnd - leftStart + 1; while(leftStart = leftEnd & rightStart = rightEnd) if(array leftStart = array rightStart ) tmpArray tmpPos+ = array leftStart+ ; else tmpArray

18、 tmpPos+ = array rightStart+ ; while(leftStart = leftEnd) tmpArray tmpPos+ = array leftStart+ ; while(rightStart = rightEnd) tmpArray tmpPos+ = array rightStart+ ; for(int i = 0; i total; i+, rightEnd- ) array rightEnd = tmpArray rightEnd ; import java.math.*;public class PI_Runnable public static v

19、oid main(String args) throws InterruptedException / TODO Auto-generated method stub /-并行运算- long startTime ,endTime; double step = 1.0 / ; works works1 = new works(1, ); works works2 = new works(2, ); works works3 = new works(3, ); Thread thread1 = new Thread(works1); Thread thread2 = new Thread(wor

20、ks2); Thread thread3 = new Thread(works3); startTime = System.currentTimeMillis();/获取并行计算的开始时的系统时间 thread1.start(); thread2.start(); thread3.start(); thread1.join();/实现线程并行 thread2.join(); thread3.join(); endTime = System.currentTimeMillis();/获取并行计算的结束时的系统时间 long ParallelTime = endTime - startTime;

21、System.out.println(PI() = + (works1.getSum() + works2.getSum() + works3.getSum() * step);/并行计算求的PI()值 System.out.println(Runnable求PI()并行时间：+ ParallelTime); /-串行运算- works works5 = new works(1, ); startTime = System.currentTimeMillis();/获取串行计算的开始时的系统时间 double PI = works5.GetPI(); endTime = System.curr

22、entTimeMillis();/获取串行计算的结束时的系统时间 long SeriaTime = endTime - startTime; System.out.println(PI() = + PI * step);/串行计算求的PI()值 System.out.println(求PI()串行时间：+ SeriaTime); /-输出相对加速比- System.out.println(相对加速比: +SeriaTime +/+ParallelTime); class works implements Runnable private long start; private long end

23、 ; private double sum; private double step; private long num_steps = ; public works(long start,long end) super(); this.start = start; this.end = end; Override public void run() / TODO Auto-generated method stub double x = 0; step = 1.0 / (double) num_steps; for (long i = start; i = end; i += 3) x = (i + 0.5) * step; sum = sum + 4.0 / (1.0 + (x*x); public double GetPI() double x = 0; step = 1.0 / (double) num_steps; for (long i = start; i = end; i +) x = (i + 0.5) * step; sum = sum + 4.0 / (1.0 + (x*x); return sum; public double getSum() return sum; 专心-专注-专业