精华内容
下载资源
问答
  • 2021-05-15 16:19:30

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

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

    long starttime,endtime;

    int[] num=new int[20001];

    for(int i=1;i<=20000;i++){

    num[i]=(int) (Math.random()*1000000);

    }

    javad sort1=new javad(1,20000);

    javad sort2=new javad(2,20000);

    starttime=System.currentTimeMillis();

    sort1.start();

    sort2.start();

    sort1.join();

    sort2.join();

    endtime=System.currentTimeMillis();

    //BubbleSort(num);

    for(int j=1;j<=20000;j++){

    System.out.println( "Value: " + num[j]);

    }

    public void run(int[] num){

    int temp;

    for(long k=start;k<=end;k+=2){

    for(int i=0 ; i < num.length ; ++i){

    for(int j=0; j

    if(num[j] > num[j + 1]){

    temp = num[j];

    num[j] = num[j + 1];

    num[j + 1] = temp;

    }

    }

    }

    }

    }

    java多线程中使用thread类通过run运行的函数怎么调用的?显示结果还是随机数组

    更多相关内容
  • 多线程冒泡排序

    2019-12-05 22:20:01
    java课的课后作业,要求实现数组的多线程冒泡排序并实现可视化,自己写了一个奇偶排序的多线程,但效率较低,现在回顾一下老师课上讲的程序。 生成的界面如上 首先实现Button1的功能,生成随机的指定大小的数组 ...

    java课的课后作业,要求实现数组的多线程冒泡排序并实现可视化,自己写了一个奇偶排序的多线程,但效率较低,现在回顾一下老师课上讲的程序。
    左边是生成的数组大小,右边可选择线程
    生成的界面如上
    首先实现Button1的功能,生成随机的指定大小的数组

    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
            // TODO add your handling code here:
            long len=(Long)jFormattedTextField1.getValue();
            int arr[]=new int[(int)len];
            for(int i=0;i<len;i++)
            {
             arr[i]=(int)(Math.random()*10000);
            }
            SortPane.ar=arr;
            
            this.repaint();
        }                  
    

    接着实现选择线程的按钮

        private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {                                         
            // TODO add your handling code here:
    
            Object value=jSpinner1.getValue();
            int tn= Integer.parseInt(value.toString());
            SortPane.mode=new int[tn];
           BubbleOrder[]bo=new BubbleOrder[tn];
    
            for(int i=0;i<tn;i++)
            {
              bo[i]= new BubbleOrder((SortPane)jPanel1,i,tn,SortPane.ar);
             
            }
       
         try {
                Thread.sleep(500);}catch(Exception e){}
        for(int i=0;i<tn;i++)
            {
              bo[i].start();
             
            }  
        } 
    

    输入的值为tn,最后生成tn个线程
    在SortPane中实现用直线表示数字大小的方法为:

        public void paint(Graphics g) {
            if(ar==null)
             super.paint(g); //To change body of generated methods, choose Tools | Templates.
            else{
                g.setColor(Color.gray);
                
          
          
          float w=this.getSize().width;
          float h=this.getSize().height; 
          g.fillRect(0, 0, this.getSize().width, this.getSize().height);
          g.setColor(Color.red);
          float w1=w/ar.length;
          w1=w1<1?1:(int)(w1+0.5);
          for(int i=0;i<ar.length;i++){
              
          g.drawLine((int)(i*w1), (int)h,(int)(i*w1) ,(int) (h*(1-ar[i]/10000.0)));//drawLine中的4个参数表示两个点的坐标
          }
          
            }
        
        }
    

    最重要的是如何实现多线程的冒泡排序以及使各线程之间同步,假设项目中使用的4个线程的冒泡排序,那么第一个线程排序下标为0,4,8…的数,第二个线程排序下标为1,5,9…的数,由此类推,当四个线程均排到最后一个数时再对最后四个数字进行排序从而找到整个数组中最小的数,找到最小的数之后再对剩下的数组按照相同的方法排序,直到只剩下4个数时用任意一个线程去排序即可得到有序的数组,下面对代码的每一步进行分析。
    1.将主函数中的参数传到各线程中,对于各参数的意义放到后面分析。

     public BubbleOrder(SortPane sp, int id, int tn, int ar[]) {
            this.id = id;
            this.tn = tn;
            ot = (int) Math.pow(tn, 2) - 1;
            this.ar = ar;
            this.sp = sp;
            BubbleOrder.len = ar.length;
    
        }
    

    2.对其进行数组每次排序后对最后四个数排序和对剩下的最后四个数排序的函数sort1进行分析

        void sort1(int len) {
            if (len > tn) {//判断是每次排序的最后找最小值还是对剩下的最后四个数
                for (int k = len - tn; k < len - 1; k++) {//一层for循环找最小值
                    if (ar[k] < ar[k + 1]) {
                        int ls = ar[k];
                        ar[k] = ar[k + 1];
                        ar[k + 1] = ls;
                    }
    
                }
            } else {//两层for循环进行排序
                for (int k = len; k > 0; k--) {
                    for (int j = 0; j < k - 1; j++) {
                        if (ar[j] < ar[j + 1]) {
                            int ls = ar[j];
                            ar[j] = ar[j + 1];
                            ar[j + 1] = ls;
                        }
                    }
                }
                exit = true;
            }
        }
    

    3.再对其中的排序函数进行分析,很容易知道此处的tn为线程数

        void sort(int len) {
            if (id > len - tn) {
                exit = true;//当剩余需排序的长度小于线程数时退出,然后采用单线程排序即可
            }
            for (int k = id; k < len - tn; k = k + tn) {//id是各线程声明的整型数值,表示线程的名字和线程排序的起点
                if (ar[k] < ar[k + tn]) {//将较小的数换到后面
                    int ls = ar[k];
                    ar[k] = ar[k + tn];
                    ar[k + tn] = ls;
                }
            }
        }
    

    3.分析线程里面的run函数
    一个for循环中,首先进行冒泡排序,然后用一个waiting表示当前线程已完成排序,等待其他线程,已完成排序的线程SortPane.get(id)方法得到false,在sortPane中声明的mode数组存储各线程的完成情况,若完成则赋值为1,

            public void run() {
            while (!exit) {
                System.out.print("Thread " + id + "   sorting\r\n");
                sort(len);
                //synchronized(SortPane.ar){
                waiting = true;
                try{
                 System.out.print("Thread " + id + "   waiting\r\n");
                 SortPane.add(id);
                 if(issorted(SortPane.mode))
                 {
                        sort1(len);
                        sp.repaint();
                        BubbleOrder.len--;
                        if (BubbleOrder.len==tn) {//当仅剩下和线程相等的数组时直接用sort1函数排序
                            sort1(len);
                            sp.repaint();
                            break;
                        }
                        SortPane.clear();
                        synchronized (SortPane.ii) {
                            SortPane.ii.notifyAll();
                        }
                 }
                 else
                 {
                     synchronized (SortPane.ii) {                       
                            //  SortPane.ar.notify();
                            if (exit) {
                                break;
                            }
                            SortPane.ii.wait();
                        }
                 }
                    
                } 
                catch (InterruptedException ex) {//好像没啥用
                }
                
    

    此处为SortPane的mode数组,用于表示各线程是否已完成当前线程的排序

      static   int[] mode;
      static   synchronized void add(int id)
        {
            mode[id]=1;
        }
    

    issorted为判断mode数组是否所有数字为1的函数

     boolean issorted(int a[])
        {
            boolean sorted=true;
            for(int i=0;i<a.length;i++)
            {
                if(a[i]!=1) sorted=false;
            }
            return sorted;
        }
    

    最后的效果如下
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • Java 多线程排序

    2021-03-04 02:47:34
    说明本节主要结合排序的实例来演示多线程执行任务的流程,主要使用了线程池 ExecutorService , 闭锁 Futrue, 完成服务 CompletionService 以及最常见的冒泡排序算法基本介绍ExecutorService 线程池private static ...

    利用并发来实现排序

    1. 说明

    本节主要结合排序的实例来演示多线程执行任务的流程,主要使用了线程池 ExecutorService , 闭锁 Futrue, 完成服务 CompletionService 以及最常见的冒泡排序算法

    基本介绍

    ExecutorService 线程池

    private static ExecutorService executorService = new ThreadPoolExecutor(5,

    10,

    60,

    TimeUnit.SECONDS,

    new LinkedBlockingDeque(10), new DefaultThreadFactory("int-sort"),

    new ThreadPoolExecutor.CallerRunsPolicy());

    上面是创建一个线程池的实例,其中几个参数分别为:(来自jdk)

    ```java

    /**

    * @param corePoolSize the number of threads to keep in the pool, even

    * if they are idle, unless {@code allowCoreThreadTimeOut} is set

    * @param maximumPoolSize the maximum number of threads to allow in the

    * pool

    * @param keepAliveTime when the number of threads is greater than

    * the core, this is the maximum time that excess idle threads

    * will wait for new tasks before terminating.

    * @param unit the time unit for the {@code keepAliveTime} argument

    * @param workQueue the queue to use for holding tasks before they are

    * executed. This queue will hold only the {@code Runnable}

    * tasks submitted by the {@code execute} method.

    * @param threadFactory the factory to use when the executor

    * creates a new thread

    * @param handler the handler to use when execution is blocked

    * because the thread bounds and queue capacities are reached

    * @throws IllegalArgumentException if one of the following holds:

    * {@code corePoolSize < 0}

    * {@code keepAliveTime < 0}

    * {@code maximumPoolSize <= 0}

    * {@code maximumPoolSize < corePoolSize}

    * @throws NullPointerException if {@code workQueue}

    * or {@code threadFactory} or {@code handler} is null

    */

    public ThreadPoolExecutor(int corePoolSize,

    int maximumPoolSize,

    long keepAliveTime,

    TimeUnit unit,

    BlockingQueue workQueue,

    ThreadFactory threadFactory,

    RejectedExecutionHandler handler) {

    if (corePoolSize < 0 ||

    maximumPoolSize <= 0 ||

    maximumPoolSize < corePoolSize ||

    keepAliveTime < 0)

    throw new IllegalArgumentException();

    if (workQueue == null || threadFactory == null || handler == null)

    throw new NullPointerException();

    this.corePoolSize = corePoolSize;

    this.maximumPoolSize = maximumPoolSize;

    this.workQueue = workQueue;

    this.keepAliveTime = unit.toNanos(keepAliveTime);

    this.threadFactory = threadFactory;

    this.handler = handler;

    }

    ```

    - Futrue

    > 就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果,该方法会阻塞直到任务返回结果

    ```java

    public interface Future {

    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)

    throws InterruptedException, ExecutionException, TimeoutException;

    }

    CompletionService

    如果向Executor提交了一组计算任务,并且希望在计算完成后获得结果,那么可以保留与每个任务关联的Future,然后反复使用get方法,同时将参数timeout指定为0,从而通过轮询来判断任务是否完成。这种方法虽然可行,但却有些繁琐。幸运的是,还有一种更好的方法:完成服务CompletionService

    2. 实例

    import io.netty.util.concurrent.DefaultThreadFactory;

    import org.junit.Test;

    import java.util.concurrent.*;

    /**

    * Created by yihui on 16/3/11.

    */

    public class RunnableTest {

    private static ExecutorService executorService = new ThreadPoolExecutor(5,

    10,

    60,

    TimeUnit.SECONDS,

    new LinkedBlockingDeque(10), new DefaultThreadFactory("sort-calculate"),

    new ThreadPoolExecutor.CallerRunsPolicy());

    /**

    * 随机生成一些数

    *

    * @param size

    * @return

    */

    private int[] genNums(final int size) {

    int[] num = new int[size];

    for (int i = 0; i < size; i++) {

    num[i] = (int) (Math.random() * 1230);

    }

    return num;

    }

    // 冒泡排序

    private int[] sort(int[] num, int size) {

    if (size <= 1) {

    return num;

    }

    int tmp;

    for (int i = 0; i < size; i++) {

    for (int j = i + 1; j < size; j++) {

    if (num[i] > num[j]) {

    tmp = num[i];

    num[i] = num[j];

    num[j] = tmp;

    }

    }

    }

    return num;

    }

    // 合并两个排序数组

    public int[] merge(int[] ans, int[] sub) {

    if (ans == null) {

    return sub;

    }

    int ansSize = ans.length;

    int subSize = sub.length;

    int[] result = new int[subSize + ansSize];

    for (int i =0, ansIndex=0, subIndex=0; i < ansSize + subSize; i ++) {

    if (subIndex >= subSize) {

    result[i] = ans[ansIndex ++];

    continue;

    }

    if (ansIndex >= ansSize) {

    result[i] = sub[subIndex ++];

    continue;

    }

    if (ans[ansIndex] < sub[subIndex]) {

    result[i] = ans[ansIndex ++];

    } else {

    result[i] = sub[subIndex ++];

    }

    }

    return result;

    }

    public int[] calculate(int[] numbers, int size) {

    CompletionService completionService = new ExecutorCompletionService(executorService);

    if (size <= 50) {

    return this.sort(numbers, size);

    }

    // 将数组分割,50个作为一组,进行排序

    int subNum = (size - 1) / 50 + 1;

    for (int i = 0; i < subNum; i++) {

    int len = 50;

    if (i == subNum - 1) {

    len = size - 50 * i;

    }

    final int[] subNumbers = new int[len];

    System.arraycopy(numbers, i * 50 + 0, subNumbers, 0, len);

    final int finalLen = len;

    Callable runnable = new Callable() {

    @Override

    public int[] call() throws Exception {

    return sort(subNumbers, finalLen);

    }

    };

    completionService.submit(runnable);

    }

    int[] ans = null;

    // 开始对提交的排序任务的结果进行合并

    try{

    for (int i = 0; i < subNum; i ++) {

    // get and remove the result

    Future f = completionService.take();

    int[] tmp = f.get();

    ans = this.merge(ans, tmp);

    }

    } catch (InterruptedException e) {

    e.printStackTrace();

    } catch (ExecutionException e) {

    e.printStackTrace();

    }

    return ans;

    }

    // 输出数组

    private void print(int[] num, int size, boolean newLine) {

    for (int i = 0; i < size; i++) {

    System.out.print(num[i] + ",");

    }

    if (newLine) {

    System.out.println();

    }

    }

    @Test

    public void tt() {

    int size = 250;

    int[] numbers = this.genNums(size);

    int[] numbers2 = new int[size];

    System.arraycopy(numbers, 0, numbers2, 0, size);

    long start = System.nanoTime();

    this.sort(numbers, size);

    long end = System.nanoTime();

    this.print(numbers, size, true);

    System.out.println("Cost is : " + (end - start) / 1000);

    this.print(numbers2, size, true);

    start = System.nanoTime();

    int[] ans = this.calculate(numbers2, size);

    end = System.nanoTime();

    this.print(ans, size, true);

    System.out.println("cost is : " + (end - start) / 1000);

    }

    // 用于测试排序算法,以及合并算法的正确性

    @Test

    public void test() {

    int size = 10;

    int[] numbers = this.genNums(size);

    int[] ans1 = this.sort(numbers, size);

    this.print(ans1, size, true);

    size += 5;

    int[] numbers2 = this.genNums(size);

    int[] ans2 = this.sort(numbers2, size);

    this.print(ans2, size, true);

    int[] ans = this.merge(ans1, ans2);

    this.print(ans, 25, true);

    }

    }

    3. 说明

    针对上面的实例,我们重点需要关注的对象集中在 calculate方法中

    执行流程:

    对数组进行分割,按照50个一组(最后一组可能不满足50个,所以需要额外注意一下)

    将子数组的排序,作为一个task扔到线程池中执行,因为要保留其返回结果,因此采用Callable 结合 CompletionService 来做,将每个task返回的结果封装到Future中,并塞入completionQueue队列中

    从完成队列中获取结果,合并排序

    完毕后返回最终的结果

    // 提交task

    completionService.submit(new Callable() {

    @Override

    public int[] call() throws Exception {

    return sort(subNumbers, finalLen);

    }

    });

    // 获取结果

    for (...) {

    // take 表示从阻塞队列中获取并移除Future === get之后remove掉

    Futrue futrue = completionService.take();

    int[] ans = futrue.get();

    }

    展开全文
  • 高分悬赏:Java语言利用多线程实现冒泡排序,要求和之前的快速排序一样,注意边界条件的拆分
  • 介绍了JAVA实现多线程的两种方法实例分享,有需要的朋友可以参考一下
  • 理解Java多线程机制。 掌握线程的创建。 了解线程的生命周期。 了解线程的调度和优先级。 掌握如何改变线程的状态。 理解线程的同步机制。 掌握线程的互斥锁定。 掌握线程的同步运行。 二、实验内容和要求 ...

    实验五 多线程

    一、实验目的

    1. 理解Java的多线程机制。
    2. 掌握线程的创建。
    3. 了解线程的生命周期。
    4. 了解线程的调度和优先级。
    5. 掌握如何改变线程的状态。
    6. 理解线程的同步机制。
    7. 掌握线程的互斥锁定。
    8. 掌握线程的同步运行。

    二、实验内容和要求

    题目:利用线程比较插入、冒泡排序算法的运行时间。

    1. 建立一个Person类,主要有name、age等私有成员变量,以age来对Person类的对象进行排序(升序)。该类实现Comparable接口,故必须实现方法public int compareTo(Object p)。
    2. 了解Comparable接口。
    3. 写两个类分别实现插入、冒泡排序,并获取其运行时间。
    4. 建立线程实现排序,注意一个时刻只让一个排序线程运行。
    5. 在main方法里启动两个线程分别实现插入和冒泡排序。

    三、实验代码

    (1) 建立一个Person类

    public class Person implements Comparable<Person>{
    
    	private String name;
    	private int age;
    	
    	
    	public Person(String s, int i) {
    		name = s;
    		age = i;
    	}
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	public int compareTo(Person p) {
    		/*if(this.age > p.getAge()) {
    			return 1;  //正整数是大于
    		} else if(this.age < p.getAge()) {
    			return -1; //负整数是小于
    		} else {
    			return 0;  //0为等于
    		}*/
    		return this.age - ((Person)p).getAge();
    	}
    	
    	public static void main(String args[]) {
    		
    	}
    }
    

    (5) 建立一个Test类在main方法中写入如下代码

    public class Test {
    
    	public static void main(String[] args) {
    		
    /*		Person p1 = new Person();
    		Person p2 = new Person();
    		Person p3 = new Person();
    		p1.setName("小明");
    		p1.setAge(15);
    		p2.setName("小红");
    		p2.setAge(12);
    		p3.setName("大红");
    		p3.setAge(13);
    		
    		ArrayList<Person> list=new ArrayList<Person>();
    		list.add(p1);
    		list.add(p2);
    		list.add(p3);
    		
    		System.out.println("排序前-------------------");
    		for (Person p : list) {
    			//System.out.println(000);
    			System.out.println(p.getAge());
    		}
    		
    		Collections.sort(list);
    		
    		System.out.println("排序后-------------------");
    		for (Person p : list) {
    			//System.out.println(000);
    			System.out.println(p.getAge());
    		}
    		
    		System.out.println("年龄最大的为"+list.get(list.size()-1).getAge());*/
    		
    		Person p[]=new Person[10000];
    	        int i;
    	    
    	        for(i=0;i<p.length;i++){
    	          p[i]=new Person("平民"+i,(int)(120*Math.random()));
    	        }	
    		
    		ThreadB t1=new ThreadB("冒泡排序",p);
    	        ThreadB t2=new ThreadB("插入排序",p);
    	        t1.start();
    	        t2.start();
    
    	}
    }
    

    (2) 建立插入排序类,并获取运行时间

    public class insertionSort {
    
        long t1;
        long t2;
    
        public void sort(Person[] p) {
    
            if (p.length == 0) {
                throw new NullPointerException("内容为空,没有要排序的内容!");
            }
    
            t1 = System.currentTimeMillis();
    
            int size = 1;
            t1 = System.currentTimeMillis();
    
            while (size < p.length) {
                insertionSort(p, size++, p[size - 1]);
            }
    
            t2 = System.currentTimeMillis();
            System.out.println("使用插入排序使用的时间是:" + (t2 - t1) + "毫秒");
            System.out.println("排序结果为:");
    
            for (int i = 0; i < p.length; i++) {
                System.out.println(p[i].getName()+" "+p[i].getAge()+";");
            }
    
        }
    
        private void insertionSort(Person[] p, int size, Person c) {
    
            for (int i = 0; i < size; i++) {
                if (c.compareTo(p[i]) < 0) {
                    System.out.println(p[i]);
    
                    for (int j = size; j > i; j--) {
                        p[j] = p[j - 1];
                    }
    
                    p[i] = c;
    
                    break;
                }
            }
        }
    }
    

    (3) 建立冒泡排序类,并获取运行时间

    public class bubbleSort {
    
        long t1;
        long t2;
    
        public void sort(Person[] p) {
    
            if (p == null) {
                throw new NullPointerException("内容为空,没有要排序的内容!");
            }
    
            Person t;
            t1 = System.currentTimeMillis();
    
            for (int i = 0; i < p.length; i++) {
                for (int j = 0; j < (p.length - i - 1); j++) {
                    if (p[j].compareTo(p[j + 1]) > 0) {
                        t = p[j];
                        p[j] = p[j + 1];
                        p[j + 1] = t;
                    }
                }
            }
    
            t2 = System.currentTimeMillis();
            System.out.println("使用冒泡排序所花的时间是:" + (t2 - t1) + "毫秒");
            System.out.println("排序结果为:");
    
            for (int i = 0; i < p.length; i++) {
                System.out.println(p[i].getName()+" "+p[i].getAge()+";");
            }
        }
    }
    

    (4) 建立线程实现排序

    class ThreadB extends Thread {
    
        String s;
        Object b;
        Person[] c;
    
        public ThreadB(String b, Person[] p) {
            s = b;
            c = p;
        }
    
        public void run() {
            synchronized (c) {
                if (s.equals("冒泡排序")) {
                    b = new bubbleSort();
                    ((bubbleSort) b).sort(c);
                } else {
                    b = new insertionSort();
                    ((insertionSort) b).sort(c);
                }
    
                System.out.println();
                System.out.println();
                System.out.println("相隔一秒钟执行下一次的排序或者结束!");
                System.out.println();
                System.out.println();
    
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    System.out.println(e.toString());
                }
            }
        }
    }
    

    四、运行结果

     

    展开全文
  • Java冒泡排序和选择排序的实现

    千次阅读 2020-03-28 11:08:10
    介绍了Java数组的冒泡排序和选择排序的实现。
  • java多线程批量处理

    2021-06-19 12:25:08
    在过往的面试中,如果候选人做过高并发的项目,我通常会让对方谈谈对于高并发的理解,但是能系统性地回答好此问题的人并不,大概分成这样几类: 1、对数据化的指标没有概念:不清楚选择什么样的指标来衡量高并发...
  • 原标题:Java程序员必知:冒泡排序和选择排序的实例、区别、优缺点ThreadLocal是一种变量类型,根据当前的线程,变量的value也会不一样,也可以理解成每个线程内都有一个变量的副本,很多人说ThreadLocal就是一个key...
  • 一般用于单线程环境下,它实现了Serializable接口,因此它支持序列化,能够通过序列化传输,但是实际上java类库中的大部分类都是实现了这个接口。实现了RandomAccess接口,支持快速随机访问,但...
  • 首先说明奇偶排序: 算法的思路是先排奇数序号的相邻2个,或者偶数序号的相邻两个,然后一直到序列有序为止,如下代码: #include<stdio.h> #include<stdlib.h> #include<stdbool.h> #include ...
  • 算法:写冒泡排序,问如何优化,简单讲了快排和堆排序的原理 数据库:解释左连接 数据库第一第二第三范式,数据库死锁 linux:怎么查看内存;怎么查看进程,ps命令一般在什么情况下使用。 什么是幂等操作?怎么解决...
  • 冒泡排序算法10.选择排序 数组算法例题 1.数组逆序 第一个和最后一个互换,第二个和倒数第二个互换,就相当于把数组想下图一样,进行对折互换,如果数组个数为奇数,则中间保持不变其余元素互换即可 import java....
  • 1. 将插入、冒泡排序算法设计成线程,启动两个以上不同的线程同时运行,计算不同排序 的运行时间。 src/com/temp/RimingTimeOfAlgorithm.java package com.temp; import java.util.Random; /** * @Auth..
  • /**多线程奇数偶数的轮流执行*/ public class TwoThreadTest {//启动线程 public static void main(String[] args) { Exchange exchange = new Exchange(); new Thread(new OddThread(exchange...
  • 题目要求编写一个C语言程序,实现基本的冒泡排序算法.算法冒泡排序,用一句话来总结:一组数中,相邻的两个数进行比较、交换,将最大(小)数交换至尾(首)部,即完成了一次冒泡排序要想对N个数字进行排序,循环N次即可.如果真...
  • Java排序可视化(冒泡+希尔+堆排+选择+递归) 1. 效果展示 **‘all’**是五种排序同时进行,以便更好观察,文末会附图说明。 这里选择的是选择排序升序。 2. 思路+代码 在熟练掌握了这五种排序思想后,首先我们在...
  • 使用java操作数组排序

    2014-08-14 10:41:06
    * * 冒泡排序方法,对float数组从大到小的排序 */ public void bubbleSortDesc(float arr[]) { float temp = 0; for (int i = 0; i ; i++) { for (int j = 0; j ; j++) { if (arr[j] [j + 1]) { ...
  • java中list排序

    2021-02-12 15:28:30
    List排序今天项目中涉及到对list的排序,特记录于此: 在Java Collection Framework中定义的List实现有Vector,ArrayList和LinkedList。这些集合提供了对对象组的索引访问。他们提供了元素的添加与删除支持。然而,...
  • 冒泡排序方:** 代码如下:package com.oraleoaec.ch06; /** * 冒泡算法 * 核心思想是:“换”,每轮确定一个最大(小)数, * 沉到数组的最后,轮数 = 个数 - 1,每轮要比较的次数 = 个数 - 轮数 * @author ...
  • 一、多线程高并发(concurrent、jvm包) 1.JUC多线程及高并发 1.1 多线程集合 1.2 cas 1.3 锁 1.4 队列 1.5 线程池 2.JVM+GC解析 demo 二、JDK8新特性(lamp包) 1.四大函数式接口 2.方法引用 3.构造器引用 4.数组...
  • 在上篇文章java多线程:volatile的深度理解文末,提到了volatile与synchronized的主要区别: volatile关键字解决的是内存可见性的问题 synchronized关键字解决的是执行控制的问题 该篇文章继续对java多线程:...
  • //定义指定线程名称的构造方法 public MyThread(String name) { //调用父类的String参数的构造方法,指定线程的名称 super(name); } public MyThread() { //不指定线程的名字,线程有默认的名字Thread-0 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,991
精华内容 7,596
关键字:

java多线程冒泡排序

java 订阅