(1)自定义多线程类OrderThread对一个无序整数集合进行排序，定义一个成员方法返回排序后的整数集合； (2)定义主类MainThread，从当前路径下的数据文件ints.txt读入大规模数量的无序整数(每一个整数在0~1000000000以内)； (3)主类MainThread使用OrderThread类创建多个线程对这些整数进行排序；要求输出所有整数的有序序列和总的计算时间。 注意：排序方法必须充分利用多线程并行执行能力。

下面是一个符合要求的Java代码示例：

OrderThread.java：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class OrderThread extends Thread {
    private List<Integer> list;

    public OrderThread(List<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        Collections.sort(list);
    }

    public List<Integer> getResult() {
        return list;
    }
}

MainThread.java：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class MainThread {
    private static final int THREAD_NUM = 4;

    public static void main(String[] args) {
        List<Integer> list = readFromFile("ints.txt");
        List<List<Integer>> subLists = divideList(list, THREAD_NUM);
        List<OrderThread> threads = new ArrayList<>();
        long startTime = System.currentTimeMillis();
        for (List<Integer> subList : subLists) {
            OrderThread thread = new OrderThread(subList);
            thread.start();
            threads.add(thread);
        }
        for (OrderThread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        List<Integer> result = mergeLists(threads);
        long endTime = System.currentTimeMillis();
        System.out.println("Sorted list: " + result);
        System.out.println("Time cost: " + (endTime - startTime) + "ms");
    }

    private static List<Integer> readFromFile(String fileName) {
        List<Integer> list = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = reader.readLine()) != null) {
                int num = Integer.parseInt(line.trim());
                list.add(num);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
    }

    private static List<List<Integer>> divideList(List<Integer> list, int n) {
        List<List<Integer>> result = new ArrayList<>();
        int size = list.size() / n;
        for (int i = 0; i < n - 1; i++) {
            result.add(list.subList(i * size, (i + 1) * size));
        }
        result.add(list.subList((n - 1) * size, list.size()));
        return result;
    }

    private static List<Integer> mergeLists(List<OrderThread> threads) {
        List<Integer> result = new ArrayList<>();
        for (OrderThread thread : threads) {
            result.addAll(thread.getResult());
        }
        Collections.sort(result);
        return result;
    }
}

在该示例中，OrderThread类继承自Thread类，表示排序线程。在其run方法中使用Collections.sort方法对传入的整数集合进行排序，排序后可通过getResult方法获取排序结果。

MainThread类为主类，读取文件ints.txt中的整数，将其分为多个子列表，分别创建OrderThread线程进行排序。在所有线程执行完成后，将各个线程的排序结果合并为一个有序列表，最后输出排序结果和计算时间。

需要注意的是，在创建线程时应将整数集合分为若干个子列表，每个线程处理一个子列表，充分利用多线程并行执行能力。在合并排序结果时也应该使用多线程，将各个线程的排序结果合并为一个有序列表。