睡眠排序法

最新推荐文章于 2022-05-02 15:22:00 发布

原创最新推荐文章于 2022-05-02 15:22:00 发布 · 275 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#睡眠排序法

多线程专栏收录该内容

1 篇文章

订阅专栏

本文介绍了一种基于线程和时间延迟的创新排序方法——睡眠排序法。通过使用CountDownLatch和CyclicBarrier两个核心类，文章详细阐述了两种实现方式：一种更注重操作便捷性，另一种则强调排序速度。通过实例演示了如何利用并发编程技巧进行数据排序。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

新鲜出炉睡眠排序法

核心类：CountDownLatch 、CyclicBarrier

CountDownLatch ：

countDown() 递减锁存器的计数，如果计数到达零，则释放所有等待的线程。
await() 使当前线程在锁存器倒计数至零之前一直等待（如果锁存器为0，则释放等待）

CyclicBarrier：

await() 在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。
在处理完所有的行之前，该线程将一直在屏障处等待。处理完所有的行之后，将执行实例化对象时所提供的 Runnable 屏障操作，并合并这些行


import java.util.List;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

/**
 * 睡眠排序法
 */
public class SleepSort{
    /**
     * 排序 相对操作方便
     * @param oldlist 需要排序的集合数据
     * @param newList 接收排序之后的集合数据
     * @param countDownLatch
     */
    public static void sort(List<Integer> oldlist, List<Integer> newList, CountDownLatch countDownLatch) {
        for (Integer obj : oldlist) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(obj * 2);
                        newList.add(obj);
                        countDownLatch.countDown(); //递减锁存器的计数，如果计数到达零，则释放所有等待的线程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    /**
     * 排序  速度相对快
     * @param oldlist 需要排序的集合数据
     * @param newList 接收排序之后的集合数据
     */
    public static void sort2(List<Integer> oldlist, List<Integer> newList, CyclicBarrier cyclicBarrier) {
        for (Integer obj : oldlist) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        try {
                            TimeUnit.MILLISECONDS.sleep(obj * 2);
                            newList.add(obj);
                            cyclicBarrier.await();
                        } catch (BrokenBarrierException e) {
                            e.printStackTrace();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

demo使用示例：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;

/**
 * 两种睡眠排序方法的测试
 * 方法一：核心类 CountDownLatch
 * 方法二：核心类 CyclicBarrier
 */
public class Demo {

    public static void main(String[] args) throws Exception {
        Integer[] arr = {2, 100, 10, 444, 55, 1, 88};
        List<Integer> oldlist = Arrays.asList(arr);
        List<Integer> newList = new ArrayList<>();
        System.err.println("原数组顺序" + oldlist);

//        testSort(oldlist,newList);

        testSort2(oldlist, newList);
    }

    // 测试sort2 相对操作方便
    public static void testSort(List<Integer> oldList, List<Integer> newList) {
        final CountDownLatch countDownLatch = new CountDownLatch(oldList.size());
        SleepSort.sort(oldList, newList, countDownLatch);
        countDownLatch.await();// 阻塞主线程，当计数器为零时释放
        System.out.println(newList);
    }

    // 测试sort 速度相对快
    public static void testSort2(List<Integer> oldList, List<Integer> newList) {
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(oldList.size(), new Runnable() {
            @Override
            public void run() { // 所有等待结束后执行该操作
                System.err.println("睡眠之后的数组排序" + newList);
            }
        });
        SleepSort.sort2(oldList, newList, cyclicBarrier);
    }
}