线程面试问题（一）

1.子线程循环 10 次，接着主线程循环 100，接着又回到子线程循环 10 次，接着再回到主线程又循环 100，如此循环 50 次。

public class ThreadTest1 {

    /**
     * 子线程循环10次，
     * 主线程循环100次
     * 子线程再次循环10次
     * 主线程再次循环100次
     * 如此循环50次
     * @param args
     */
    public static void main(String[] args) {
        new ThreadTest1().init();
    }

    public void init() {
        Business business = new Business();
        //子线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50; i++) {
                    business.subThread(i);
                }
            }
        }).start();
      //主线程
        for (int i = 0; i < 50; i++) {
            business.mainThread(i);
        }
    }
}

class Business {

    boolean bShouldSub = true;

    //主线程
    public synchronized void mainThread(int i) {
        if (bShouldSub) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        for (int j = 0; j < 100; j++) {
            System.out.println(Thread.currentThread().getName() + ":i=" + i + ",j=" + j);
        }

        bShouldSub = true;
        this.notify();
    }

    public synchronized void subThread(int i) {
        if (!bShouldSub) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        for (int j = 0; j < 10; j++) {
            System.out.println(Thread.currentThread().getName() + ":i=" + i + ",j=" + j);

        }
        bShouldSub = false;
        this.notify();
    }
}

2.设计 4 个线程，其中两个线程每次对 j 增加 1，另外两个线程对 j 每次减少1。

public class A {

    JManger j = new JManger();

    public static void main(String[] args) {
        new A().call();
    }

    void call() {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                        j.accumulate();
                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    j.subtract();
                }
            }).start();
        }
    }
}

class JManger {
    private int j = 0;

    public synchronized void subtract() {
        j--;
        System.out.println(Thread.currentThread().getName()+"-sub:"+j);
    }

    public synchronized void accumulate() {
        j++;
        System.out.println(Thread.currentThread().getName()+"-acc:"+j);
    }
}