睡眠排序法

新鲜出炉睡眠排序法

核心类 ：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 oldlist, List 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 oldlist, List 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 oldlist = Arrays.asList(arr);
        List newList = new ArrayList<>();
        System.err.println("原数组顺序" + oldlist);

//        testSort(oldlist,newList);

        testSort2(oldlist, newList);
    }

    // 测试sort2 相对操作方便
    public static void testSort(List oldList, List 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 oldList, List newList) {
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(oldList.size(), new Runnable() {
            @Override
            public void run() { // 所有等待结束后执行该操作
                System.err.println("睡眠之后的数组排序" + newList);
            }
        });
        SleepSort.sort2(oldList, newList, cyclicBarrier);
    }
}