Java基础 线程的通信的三个方法/ 交替数数线程 / 生产者&消费者线程问题

线程通讯笔记:

/** 线程通信 三个方法:
 *      wait(): 调用该方法 是该调用的方法的线程释放共享资源的锁,进入等待状态,直至被唤醒
 *      notify() : 可以唤醒队列中的第一个等待同一共享资源的线程, 并使该线程退出等待队列,进入可运行状态
 *      notifyALL() : 全部唤醒,优先级最高的先执行!!!
 * ---------------------------------------------------------------
 *     例一:  使用两个线程 打印1-100,线程,两个线程交替打印
 *          ***方法: 一个线程先打印,打印完毕,先notifyALL,再接着 wait();
 *
 */

线程交替数数代码:

class PrintNum2 implements Runnable{
    int num=1;
    @Override
    public void run() {
        while(num<=30){

            synchronized (this) {
                if(num<=30){
                    System.out.println(Thread.currentThread().getName()+" : "+num);
                    num++;
                }
                else{
                    break;
                }
                notifyAll();
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}
public class TestComm {
    public static void main(String[] args) {
        PrintNum2 p=new PrintNum2();
        Thread t1=new Thread(p);
        Thread t2=new Thread(p);

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

交替数数的测试结果:

Thread-0 : 1
Thread-1 : 2
Thread-0 : 3
Thread-1 : 4
Thread-0 : 5
Thread-1 : 6
Thread-0 : 7
Thread-1 : 8
Thread-0 : 9
Thread-1 : 10
Thread-0 : 11
Thread-1 : 12
Thread-0 : 13
Thread-1 : 14
Thread-0 : 15
Thread-1 : 16
Thread-0 : 17
Thread-1 : 18
Thread-0 : 19
Thread-1 : 20
Thread-0 : 21
Thread-1 : 22
Thread-0 : 23
Thread-1 : 24
Thread-0 : 25
Thread-1 : 26
Thread-0 : 27
Thread-1 : 28
Thread-0 : 29
Thread-1 : 30

---

 生产者&消费者线程问题:

/** 生产者/消费者 问题
 *          1.生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品
 *          2.店员一次只能持有固定数量的产品(比如:20），
 *          3.如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产
 *          4.如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
 * ----------------------------------
 *      分析:
 *      1.是否涉及多线程的同步问题!
 *      2.谁是共享数据!谁是共享代码块!
 */

问题模型内容:

代码演示: (每个消费者和生产者生产或者消费的产品个数都不超过10个 ,为了方便起见!太多的话, 输出结果太长了2333)

class Clerk{  //店员
    int product;
    public synchronized void addProduct() {  //生产产品
        if(product>=20)
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        else{
           product++;
            System.out.println(Thread.currentThread().getName()+" 生产了 "+product+"个产品!");
            notifyAll();
        }
    }
    public synchronized void consumeProduct(){
        if(product<=0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        else{
            System.out.println(Thread.currentThread().getName()+" 消费了第 "+product+"个产品!");
            product--;
            notifyAll();
        }
    }
}
class Productor implements Runnable{  //生产者 类
   Clerk clerk;
    int num;
    public Productor(Clerk clerk) {
        this.clerk = clerk;
        this.num=0;
    }
    public void run() {
        System.out.println("生产者开始生产产品!!");
        while (this.num<10){
            try {
                Thread.currentThread().sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num++;
            clerk.addProduct();
        }
    }
}

class Consumer implements Runnable{
    Clerk clerk;
    int num;
    public Consumer(Clerk clerk) {
        this.clerk = clerk;
        this.num=0;
    }
    public void run(){
        System.out.println("消费者消费产品!");
        while (this.num<10){
            try {
                Thread.currentThread().sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num++;
            clerk.consumeProduct();
        }
    }
}

public class Productor_Customer {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Productor p1=new Productor(clerk);
        Consumer c1=new Consumer(clerk);

        Thread t1=new Thread(p1," 生产者1 线程 ");
        Thread t3=new Thread(p1," 生产者2 线程 ");
        Thread t2=new Thread(c1," 消费者线程 ");
        t1.start();
        t2.start();
        t3.start();
    }
}

结果输出:

生产者开始生产产品!!
生产者开始生产产品!!
消费者消费产品!
 生产者2 线程  生产了 1个产品!
 生产者1 线程  生产了 2个产品!
 生产者2 线程  生产了 3个产品!
 消费者线程  消费了第 3个产品!
 生产者1 线程  生产了 3个产品!
 消费者线程  消费了第 3个产品!
 生产者2 线程  生产了 3个产品!
 生产者1 线程  生产了 4个产品!
 消费者线程  消费了第 4个产品!
 生产者2 线程  生产了 4个产品!
 生产者1 线程  生产了 5个产品!
 消费者线程  消费了第 5个产品!
 生产者1 线程  生产了 5个产品!
 生产者2 线程  生产了 6个产品!
 生产者1 线程  生产了 7个产品!
 消费者线程  消费了第 7个产品!
 生产者2 线程  生产了 7个产品!
 消费者线程  消费了第 7个产品!
 消费者线程  消费了第 6个产品!
 消费者线程  消费了第 5个产品!
 消费者线程  消费了第 4个产品!