java上机第十四周任务一线程的练习

╰半橙微兮° 2022-05-14 08:10 119阅读 0赞

/* 
    * 程序头部注释开始   
    * 程序的版权和版本声明部分   
    * Copyright (c) 2011, 烟台大学计算机学院学生   
    * All rights reserved.   
    * 文件名称：线程的练习                           
    * 作    者：薛广晨                               
    * 完成日期：2012  年 11 月  29日   
    * 版 本号：x1.0            
       
    * 对任务及求解方法的描述部分   
    * 输入描述：  
    * 问题描述: 先封装一类对象RandomNumber，功能是先产生一个大于10的随机整数n，再产生n个随机数并存放于数组中。
    *        然后封装两个线程Thread1（要求是Thread的子类）和Thread2（要求实现Runnable接口）并发地对所生成的随机数进行排序，
    *        其中Thread1要求采用冒泡排序法进行排序，并输出排序结果。Thread2要求采用快速排序法进行排序，并输出排序结果。
    *        最后编写主线程TestThread，加入上述两个线程实现程序的并发，比较这两个线程排序的结果
    * 程序输出：   
    * 程序头部的注释结束 
    */
    
    //主线程Test
    package xue;
    
    public class Test {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Thread1 thread1 = new Thread1();
    		Thread2 thread2 = new Thread2();
    		Thread th2 = new Thread(thread2);
    		thread1.start();
    		th2.start();
    	}
    
    }
    
    //RandomNumber类  产生随机数
    package xue;
    
    public class RandomNumber {
    	public int []num;
    	public int n;
    	
    	RandomNumber()
    	{
    		n = (int)(Math.random()*10 + 10);
    		num = new int[n];
    	}
    	public int[] getNum() {
    		return num;
    	}
    
    	public void produceRd()
    	{
    		
    		for(int x = 0; x < num.length; x++)
    		{
    			num[x] = (int)(Math.random()*10 + 10); 
    		}	
    	}
    }
    
    
    //线程Thread1
    package xue;
    
    public class Thread1 extends Thread {
    	public void run()
    	{
    		int temp;
    		RandomNumber randomNum = new RandomNumber();
    		int[] rdn = new int[randomNum.n];
    		randomNum.produceRd();
    		for(int i = 0; i < randomNum.n; i++)
    		{
    			rdn[i] = randomNum.num[i];
    		}
    		
    		
    		for(int x = 0; x < rdn.length - 1; x++)
    			for(int y = 0; y < rdn.length - x - 1; y++)
    			{
    				if(rdn[y] > rdn[y+1])
    				{
    					temp = rdn[y];
    					rdn[y] = rdn[y+1];
    					rdn[y+1] = temp;
    				}
    			}
    		System.out.println("线程一    冒泡排序法排序：");
    		for(int num : rdn)
    		{
    			System.out.println("线程一  冒泡排序：---" + num);
    		}
    
    	}
    }
    
    
    //线程Thread2（要求实现Runnable接口）
    package xue;
    
    public class Thread2 implements Runnable {
    	private static void sort(int[] a, int first, int last)  
    	  
    	    {  
    	  
    	        int i = first;  
    	        int j = last;  
    	        int middle = a[first]; // 第一次调用时候我选取要排序的数组的第一个数作为关键数据  
    	        while (true) {  
    	            while (++i < last - 1 && a[i] < middle)  
    	                ;  
    	            while (--j > first && a[j] > middle)  
    	                ;  
    	            if (i >= j) {  
    	                break;  
    	            }  
    	            swap(a, i, j);  
    	        }  
    	        a[first] = a[j];  
    	        a[j] = middle;  
    	  
    	        if (first < j) {  
    	            sort(a, first, j);  
    	        }  
    	        if (i < last) {  
    	            sort(a, i, last);  
    	        }  
    	    }  
    	  
    	    private static void swap(int[] a, int i, int j) {  
    	        int temp = a[i];  
    	        a[i] = a[j];  
    	        a[j] = temp;  
    	    } 
    
    	   public void run() {
    			RandomNumber randomNum = new RandomNumber();
    			randomNum.produceRd();
    			int[] rdn1 = randomNum.getNum();
    			sort(rdn1, 0, rdn1.length);
    			System.out.println("线程二   快速排序法排序：");
    			for(int num : rdn1)
    			{
    				System.out.println("线程二   快速排序：--------" + num);
    			}		
    		}
    }

运行结果：

![1354201504_9145.jpg][]

[1354201504_9145.jpg]: https://img-my.csdn.net/uploads/201211/29/1354201504_9145.jpg