package Test;
/**
*创建两个线程交替输出数组中的元素.
* @author 木木
*/
/*
* 分析：通过使用两次obj.notify();wait()机制，从而实现两个线程之间交替运行。
* 执行过程： 1拿了索引后等待， 2拿完索引叫醒1（2等待），1输出数组元素后叫醒2（1等待），2输出数组元素后叫醒1（2等待），1拿完索引后叫醒2（1等待），2拿完索引叫醒1（2等待）...直到遍历完毕。
*/
public class Test05C {
        public static void main(String[] args) {
                // 定义数组，final修饰，供局部内部类访问。
                final int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
                // 定义锁，final修饰，供局部内部类访问。
                final Object obj = new Object();
                // 匿名内部类创建线程，线程命名为"第1线程"并且启动第1线程。
                new Thread(new Runnable() {
                        // 重写run方法。
                        public void run() {
                                // 异常处理。
                                try {
                                        // 设值锁，obj为公用的锁对象。
                                        synchronized (obj) {
                                                // 循环遍历数组
                                                for (int i = 0; i < 10; i++) {
                                                        // 获取索引i,唤醒线程，第一次运行没有等待的线程可唤醒。
                                                        obj.notify();
                                                        // 第1线程进入等待，释放锁。转入第2线程，当第2线程获取索引i后同样执行唤醒线程释放锁并等待。
                                                        // 第1线程获得锁往下执行程序。
                                                        obj.wait();
                                                        // 输出一个数组元素。
                                                        System.out.println(Thread.currentThread().getName()
                                                                        + arr);
                                                        // 输出一个元素后，唤醒第2线程中正在等待的线程，第1线程进入等待。
                                                        obj.notify();
                                                        obj.wait(100);
                                                }
                                        }
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                }, "第1线程").start();
                // 匿名内部类创建线程，线程命名为"第2线程"并且启动第1线程。
                new Thread(new Runnable() {
                        // 重写run方法。
                        public void run() {
                                // 异常处理。
                                try {
                                        synchronized (obj) {
                                                for (int i = 0; i < 10; i++) {
                                                        // 唤醒第1线程并进入等待
                                                        obj.notify();
                                                        // 第2线程进入等待，转入执行另一线程。
                                                        obj.wait();
                                                        // 输出一个数组元素。
                                                        System.out.println(Thread.currentThread().getName()
                                                                        + arr);
                                                        // 输出一个元素后，唤醒第1线程中正在等待的线程，第2线程进入等待。
                                                        obj.notify();
                                                        obj.wait(100);
                                                }
                                        }
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                }, "第2线程").start();
        }
}

母鸡啊，锁什么的都还没有学过，r

膜拜