线程同步面试题，3个线程打印一个1-100的数组，要求P1=1，P2=2，P3=3，P1=4的形式

当时没有答好回来总结一下总结了两个方式
一，这个方式是利用Object.notify(),Object.wait(),两个方法来实现。
中心思想：保证应该到哪个线程打印时，只有该线程是唤醒状态，其他都是暂停状态。比如需要P1打印1，那就要让P2，P3都是wait()状态。

package com.example.ly.mydemo;public class WaitObjectTest implements Runnable {    private static int i = 0;    private Object selfO = null;    private Object pref = null;    public WaitObjectTest(Object selfO, Object pref) {        this.selfO = selfO;        this.pref = pref;    }    @Override    public void run() {        System.out.println("threadId: " + Thread.currentThread().getName());        while (i < 30) {            synchronized (pref) {                synchronized (selfO) {                    System.out.println("threadId: " + Thread.currentThread().getName() + "  i: " + i);                    i++;                    try {                        Thread.sleep(500);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                        selfO.notify();                }                try {                    pref.wait();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }    }    public static void main(String[] args) {        int[] object1 = new int[0];        int[] object2 = new int[0];        int[] object3 = new int[0];        WaitObjectTest mRunnableA = new WaitObjectTest(object1, object3);        WaitObjectTest mRunnableB = new WaitObjectTest(object2, object1);        WaitObjectTest mRunnableC = new WaitObjectTest(object3, object2);        Thread threadA = new Thread(mRunnableA, "A");        Thread threadB = new Thread(mRunnableB, "B");        Thread threadC = new Thread(mRunnableC, "C");        threadA.start();        try {            Thread.sleep(10);        } catch (InterruptedException e) {            e.printStackTrace();        }        threadB.start();        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        threadC.start();    }}

二，这个方式我和朋友一个完善的一个方法，中心思想是：只synchronized数组，用循环来控制打印，就是打印需要的不需要的就continue。

   class A implements Runnable {        Thread p1, p2, p3;        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8,9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21};        int count = 0;        public A() {            p1 = new Thread(this,"0");            p2 = new Thread(this,"1");            p3 = new Thread(this,"2");            p1.start();            p2.start();            p3.start();        }        @Override        public void run() {            while (count < arr.length) {                synchronized (arr) {                    String threadName = Thread.currentThread().getName();                    if (count % 3 == Integer.valueOf(threadName)) {                        LogUtils.writeLog("p:" + (Integer.valueOf(threadName)+1) + "=" + arr[count]);                        count++;                    } else {                        continue;                    }                }            }        }    }

总结：
1.第一个方法是朋友提供的，其实我不是很喜欢代码多，可读性差，但是第一个种方法可以帮助理解线程同步的原理，所以也贴出来大家一起学习一下。
2.第二种方法是我跟朋友一起总结出来的。是我自己觉得比较好的方式，毕竟核心代码比较少，而且满足了需求。
3.线程同步主要是synchronized关键字来控制访问，必要时配合Object的Object.notify(),Object.wait()，两个方法，实际上Java还提供了专门针对线程同步问题的类，回头再针对线程同步问题做一篇总结吧。