Java基础：多线程之面试问题

    多个线程访问共享对象和数据的方式：
1.如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，卖票系统就可以这么做。
2.如果每个线程执行的代码不同，这是需要用不同的Runnable对象，有如下两种方式来实现这些Runnable对象之间的数据共享：
    2.1 将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信（如生产者消费者的实现方式）；
    2.2 将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各个操作的互斥和通信，作为内部类的各个Runnable对象调用外部类的这些方法；
    2.3 上面两种方式的结合：将共享数据封装在另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象上去完成，对象作为这个外部类的成员变量或方法中的局部变量，每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。
    总之：要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放到同一个类中，这样比较容易实现它们之间的同步互斥和通信。

1. 问题1
    面试问题：子线程循环10次，接着主线程循环30次，接着又回到子线程循环10次，接着再回到主线程循环30次，如此循环20次，请写出程序。
    分析：
    1）有两个线程一次交替执行，则需要一个共享的flag变量来判断执行次序，则需要互斥访问和等待唤醒机制；
    2）两个线程的运行任务分别为循环10次和循环30次，线程任务应封装到线程的run()方法中；
    3）子线程和主线程交替执行，循环20次，则需要一个外层for循环；
    具体实现代码如下（采用上述2.1的实现方式）：

public class Question1 {
    public static void main(String[] args){
        final Bussiness bussiness=new Bussiness();
        Thread t1=new Thread(new Runnable(){
            public void run() {
                for(int i=1;i<=20;i++){
                    bussiness.subRun(i);
                }   
            }
        } );
        t1.start();

        for(int i=1;i<=20;i++){
            bussiness.mainRun(i);
        }   
    }
}


class Bussiness{
    //共享数据封装在另外一个对象中
    private static boolean flag=true; 

    //对共享数据的操作方法也分配到这个对象上
    public synchronized void subRun(int i) {
        while(!flag){//使用while防止伪唤醒，使用if在多生产多消费的情况下会有问题
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        for (int j = 1; j <= 10; j++) {
            System.out.println("sub thread sequence of " + j + "; loop of " + i);
        }
        flag = false;
        this.notify();
    }

    public synchronized void mainRun(int i) {
        while (flag){
            try {
                this.wait();
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
        }

        for (int j = 1; j <= 30; j++) {
            System.out.println("main main mian main thread sequence of "+ j + "; loop of " + i);
        }
        flag = true;
        this.notify();
    }
}

    经验：要用到共同数据（包括同步锁）或共同算法的若干方法应该归在同一个类身上，这种设计体现了高类聚和程序健壮性。

2.问题2
    面试问题：设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1，写出程序。
    分析：共享数据j，对这个共享数据操作的两个方法：增加和减少。
    具体实现代码如下（采用上述2.2的实现方式）：

public class Question2 {

    //共享数据作为外部类的成员变量
    private  int j;

    @Test
    public void test(){
        IncRunnable incR=new IncRunnable();
        DecRunnable decR=new DecRunnable();
        Thread t1=new Thread(incR);
        Thread t2=new Thread(incR);
        Thread t3=new Thread(decR);
        Thread t4=new Thread(decR);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

    //对共享数据的操作方法也分配给外部类，以便实现对共享数据的各个操作的互斥和通信
    private synchronized void inc(){
        j++;
        System.out.println(Thread.currentThread().getName()+" inc: "+ j);
    }

    private synchronized void dec(){
        j--;
        System.out.println(Thread.currentThread().getName()+" dec: "+ j);
    }

    //将Runnable对象作为外部类Question2的内部类
    class IncRunnable implements Runnable{
        @Override
        public void run() {
            for(int i=0;i<10;i++)
                //作为内部类的Runnable对象调用外部类操作数据的方法inc()
                inc();
        }
    }

    class DecRunnable implements Runnable{
        @Override
        public void run() {
            for(int i=0;i<10;i++)
                dec();
        }
    }
}