java生产者消费者模式练习

/**
 * 
 */
package ThreadTest;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;



/**
 * @ClassName: ThreadCommunicationTest3
 * @Description:TODO
 * @author 10165212
 * @date 2016-2-24 下午6:31:51
 */
public class ThreadCommunicationTest3 {

    private  boolean flag = false;
    private Object object = new Object();

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        ThreadCommunicationTest3 test3 = new ThreadCommunicationTest3();
        service.execute(test3.new RunnableA());
        service.execute(test3.new RunnableB());
    }

    private class RunnableA implements Runnable {
        int i=0;
        @Override
        public void run() {
           while(true){
                synchronized (object) {
                    try {
                        if (flag) {
                            object.wait();//该方法运行后线程会阻塞，并释放锁。直到有notify，才会唤醒，处于就绪态。分配到资源后，才会接着向下运行。
                        } else {
                            System.out.println("i:" + i++);
                            //flag = true;写在这里和写在下面一样，因为只有方法运行完才会释放锁
                            object.notifyAll();
                            flag = true;
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private class RunnableB implements Runnable {
        int j=0;
        @Override
        public void run() {
            while(true){
                synchronized (object) {
                    try {
                        if (!flag) {
                            object.wait();
                        } else {
                            System.out.println("j:" + j++);
                            flag = false;
                            object.notifyAll();
                            
                        }
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

}

/**
 * 
 */
package ThreadTest;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @ClassName: ThreadCommunicationTest3
 * @Description:两个线程循环间隔打印指定内容，一个打印从1到52的数字，一个打印从A到Z的字母，打印输出如下：12A34B......5152Z
 * @author 10165212
 * @date 2016-2-24 下午6:31:51
 */
public class ThreadCommunicationTest4 {

    private boolean flag = false;
    private Object object = new Object();
    private char currentChar = 'A';

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        ThreadCommunicationTest4 test4 = new ThreadCommunicationTest4();
        service.execute(test4.new RunnableA());
        service.execute(test4.new RunnableB());
        service.shutdown();
    }

    private class RunnableA implements Runnable {
        @Override
        public void run() {
            for (char currentChar = 'A'; currentChar <= 'Z'; currentChar++) {
                System.out.println("A的下一个循环到来，等待获取锁");
                synchronized (object) {
                    System.out.println("线程A获取锁");
                    try {
                        if (!flag) {
                            System.out.println("线程A进入wait");
                            object.wait();
                        } 
                        System.out.println(currentChar);
                        flag = false;
                        System.out.println("线程A唤醒所有线程");
                        object.notifyAll();
                        
                        //Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("线程A释放锁");
            }
        }
    }

    private class RunnableB implements Runnable {

        @Override
        public void run() {
            for (int j = 1; j <= 52; j++) {
                System.out.println("B的下一个循环到来，等待获取锁");
                synchronized (object) {
                    System.out.println("线程B获取锁");
                    try {
                        if (flag) {
                            System.out.println("线程B进入wait");
                            object.wait();
                        }
                        System.out.println(j);
                        if (j % 2 == 0) {
                            flag = true;
                            System.out.println("线程B唤醒所有线程");
                            object.notifyAll();
                        }
                        //Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("线程B释放锁");
            }
        }
    }
}