已知一个数组[2,4,6,2,1,5],将该数组进行排序（降序，不能用工具类进行排序），创建两条线程交替输出排序后的数组，线程名自定义

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Test3 {
/*
我是这样做的，不知道对不对
* 3，已知一个数组[2,4,6,2,1,5],将该数组进行排序（降序，不能用工具类进行排序），创建两条线程交替输出排序后的数组，线程名自定义
*/
        public static void main(String[] args) {
                int[] arr ={2,4,6,2,1,5};                //定义数组
                bubblesort(arr);                               
                print(arr);                                               
               
                System.out.println("----------排序后交替执行---------");
                final printer p = new printer();//局部内部类使用局部变量用final修饰
                new Thread() {
                        public void run() {
                                while(true) {
                                        try {
                                                p.print1();
                                        } catch (Exception e) {
                                               
                                                e.printStackTrace();
                                        }
                                }
                        }
                }.start();
                new Thread() {
                        public void run() {
                                while(true) {
                                        try {
                                                p.print2();
                                        } catch (Exception e) {
                                               
                                                e.printStackTrace();
                                        }
                                }
                        }
                }.start();
}
        /*
         * 冒泡排序
         * 1，返回值类型void
         * 2，参数列表int[] arr
         */
        public static void bubblesort(int[] arr) {
                for (int i = 0; i < arr.length - 1; i++) {        //外循环只需要比较arr.length - 1
                        for (int j = 0; j < arr.length - 1 - i; j++) {//内循环-1是为了防止索引越界，-i是为了提高效率
                                if(arr[j] < arr[j + 1]) {
                                        int temp = arr[j];
                                        arr[j] = arr[j + 1];
                                        arr[j + 1] = temp;
                                }
                        }
                }
        }
        /*
         * 打印数组
         * 1，返回值类型void
         * 2，参数列表int[] arr
         */
        private static void print(int[] arr) {
                for (int i = 0; i < arr.length; i++) {
                        System.out.print(arr[i] + " ");
                }
        }
}

class printer {
        private ReentrantLock r = new ReentrantLock();        //私有ReentrantLock多象
        private Condition c1 = r.newCondition();                //创建第一个监听器
        private Condition c2 = r.newCondition();                //创建第二个监听器
       
        private int flag = 1;                                                        //定义一个标记
        public void print1() throws Exception {
                r.lock();                                                                       
                if(flag != 1) {
                        c1.await();
                }
                System.out.println("6 5 4 2 2 1 ");
                System.out.println("\r\n");
                flag = 2;
                c2.signal();
                r.unlock();
        }
        public void print2() throws Exception {
                r.lock();
                if(flag != 2) {
                        c2.await();
                }
                System.out.println("6 5 4 2 2 1 ");
                System.out.println("\r\n");
                flag = 1;
                c1.signal();
                r.unlock();
        }
}