模拟左右手写字（输出的结果）：
    左手写字
    左手写字
    主线程
    主线程
    右手写字
    右手写字
    主线程
    主线程
    ..............
求高手！

用多线程写不是谁抢到执行权就输出谁是随机的,等高手解惑

创建两个线程并开启，一个输出左手一个输出右手，主函数输出主线程， 不过不可能完全和你的一样，线程是随机的

估计是我没看懂你的问题  如果一直是像你那样有序的 估计是你没有开启线程，只是主线程在执行

class tb {
       
        public static void main(String[] args) {
                final Printer p = new Printer();
               
                new Thread(){
                        public void run() {
                                while(true)
                                        try {
                                                p.print1();
                                        } catch(Exception e) {
                                                e.printStackTrace();       
                                        }
                        }       
                }.start();
               
                new Thread(){
                        public void run() {
                                for(;;)
                                        try {
                                                p.print2();
                                        } catch(Exception e) {
                                                e.printStackTrace();       
                                        }
                        }       
                }.start();
               
                new Thread(){
                        public void run() {
                                for(;;)
                                        try {
                                                p.print3();
                                        } catch(Exception e) {
                                                e.printStackTrace();       
                                        }
                        }       
                }.start();
                new Thread(){
                        public void run() {
                                for(;;)
                                        try {
                                                p.print4();
                                        } catch(Exception e) {
                                                e.printStackTrace();       
                                        }
                        }       
                }.start();
        }
               
}

class Printer {
        private int flag = 1;       
        private ReentrantLock lock = new ReentrantLock();        // 锁对象
        private Condition c1 = lock.newCondition();                        // 与锁对象对应的分支对象
        private Condition c2 = lock.newCondition();
        private Condition c3 = lock.newCondition();
        private Condition c4 = lock.newCondition();

        public void print1() throws Exception {                       
                lock.lock();
                if (flag != 1)       
                        c1.await();                                // 用c1对象等待
               
                System.out.println("左手写字");       
                System.out.println("左手写字");       
                System.out.print("\r\n");       
                flag = 2;                       
                c2.signal();                                // 唤醒在c2对象上等待的线程
                lock.unlock();
        }
       
        public void print2() throws Exception {
                lock.lock();
                if (flag != 2)       
                        c2.await();                                //用c2对象等待
       
                System.out.println("主线程");       
                System.out.println("主线程");       
                System.out.print("\r\n");
                flag = 3;                       
                c3.signal();                                // 唤醒在c3对象上等待的线程
                lock.unlock();
        }
       
        public void print3() throws Exception {
                lock.lock();
                if (flag != 3)               
                        c3.await();                                //用c3对象等待
               
                System.out.println("右手写字");       
                System.out.println("右手写字");       
                System.out.print("\r\n");
                flag = 4;                       
                c4.signal();                                // 唤醒在c4对象上等待的线程
                lock.unlock();
        }
        public void print4() throws Exception {
                lock.lock();
                if (flag != 4)               
                        c4.await();                                //用c4对象等待
               
                System.out.println("主线程");       
                System.out.println("主线程");       
                System.out.print("\r\n");
                flag = 1;                       
                c1.signal();                                // 唤醒在c1对象上等待的线程
                lock.unlock();
        }
       
}
这个方法用到了：
1.同步
使用ReentrantLock类的lock()和unlock()方法进行同步
2.通信
使用ReentrantLock类的newCondition()方法可以获取Condition对象
需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了
不知道是不是你想要的结果。。。

谢谢！我试一下。