多线程睡眠排序法：使用4种创建线程的方式

多线程睡眠排序法：使用4种创建线程的方式

package test;

import java.util.concurrent.*;

/**
 * @ClassName SleepSort
 * @Description 多线程睡眠排序：使用四种创建线程的方式分别实现
 * @Author 86150
 * @Date 2022/4/7 12:30
 * @Version 1.0
 */

public class SleepSortTest {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 98, 44, 32};
        //sleepSortThread(arr);
        //sleepSortRunnable(arr);
        //sleepSortCallable(arr);
        //sleepSortThreadPool2(arr);
    }

    //继承Thread类
    public static void sleepSortThread (int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int num = arr[i]; //内部类中使用但未声明的任何局部变量必须在内部类的正文之前明确分配
            new Thread() {
                @Override
                public void run() {
                    try {
                        sleep(num);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(num);
                }
            }.start();
        }
    }

    //实现Runnable接口
    public static void sleepSortRunnable (int[] arr) {
        for (int num : arr) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(num);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(num);
                }
            }).start();
        }
    }

    //实现Callable接口
    public static void sleepSortCallable (int[] arr) {
        for (int num : arr) {
            new Thread(new FutureTask(new Callable() {
                @Override
                public Object call() throws Exception {
                    try {
                        Thread.sleep(num);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(num);
                    return null;
                }
            })).start();
        }
    }

    //实现线程池ThreadPool
    public static void sleepSortThreadPool1 (int[] arr) {
        ExecutorService service = Executors.newFixedThreadPool(arr.length);
        for (int num : arr) {
            service.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(num);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(num);
                }
            });
        }
    }

    //实现线程池ThreadPool：使用Lambda表达式
    public static void sleepSortThreadPool2 (int[] arr) {
        ExecutorService service = Executors.newFixedThreadPool(arr.length);
        for (int num : arr) {
            //实际这里通过Lambda表达式定义了一个Runnable接口的匿名子类(内部类)的匿名对象
            service.execute(() -> {
                try {
                    Thread.sleep(num);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(num);
            });
        }
    }
}