知识点:多线程中经典的生产者&消费者场景

在多线程编程中，生产者-消费者问题是一种经典的同步问题，涉及到一个生产者线程和一个消费者线程共享一个有限的缓冲区。生产者负责生成数据并将其放入缓冲区，而消费者负责从缓冲区中取出数据并进行处理。
这个问题的关键在于如何确保生产者和消费者之间的正确协作，以避免数据竞争和死锁等问题。

第一个例子：让两个线程交替打印从1~100的数字

public class PrintNumberTest {
    public static void main(String[] args) {
        PrintNumber p = new PrintNumber();
        Thread t1 = new Thread(p, "线程1");
        Thread t2 = new Thread(p, "线程2");


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

class PrintNumber implements Runnable {
    private int number = 1;
    Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                notify();
                if (number <= 100) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;

                    try {
                        wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }else {
                    break;
                }
            }
        }

    }
}

主要引入了wait() 和 notify()方法的使用
这段代码主要包括一个PrintNumber类实现了Runnable接口，并在其run方法中使用synchronized关键字进行同步操作。在main方法中创建了两个线程，并启动这两个线程。这两个线程共享一个PrintNumber对象，并通过synchronized关键字控制打印数字的顺序。每个线程在打印数字之后都会调用wait方法，释放锁并进入等待状态，直到另一个线程调用notify方法唤醒它继续执行。该过程循环进行，直到数字打印完毕。

第二个：生产者和消费者的实例

生产者方法

class Producer extends Thread {
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println("生产者开始生产商品...");
            try {
                Thread.sleep(50);//sleep是为了输出慢一点 以便更好分析(觉得碍眼可以删掉所有sleep)
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            clerk.addProduct();

        }
    }
}

消费者方法

class Consumer extends Thread {
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println("消费者开始消费商品...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            clerk.minusProduct();
        }
    }
}

店员方法

class Clerk {
    private int productNum = 0;//产品的数量

    //增加产品数量的方法
    public synchronized void addProduct() {
        if(productNum>=20){
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        productNum++;
        System.out.println(Thread.currentThread().getName() + "生产了第" + productNum + "个产品");
        notify();
    }

    //减少产品数量的的方法
    public synchronized void minusProduct() {
        if(productNum <= 0){
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println(Thread.currentThread().getName() + "减少了第" + productNum + "个产品");
        productNum--;

        notify();
    }
}

主测试类

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

        p1.setName("生产者1");
        c1.setName("消费者1");

        p1.start();
        c1.start();

    }

}

这段代码中，Clerk类表示店员，维护一个产品数量变量。生产者Producer和消费者Consumer类继承自Thread类，分别表示生产者和消费者。
生产者不断生产产品，通过调用Clerk的addProduct()方法将产品数量加一。如果产品数量达到上限（20），生产者将等待（调用wait()方法）。消费者不断消费产品，通过调用Clerk的minusProduct()方法将产品数量减一。如果产品数量为0，消费者将等待（调用wait()方法）。
通过使用synchronized关键字修饰Clerk的addProduct()和minusProduct()方法，实现了对产品数量的互斥访问。当产品数量发生变化时，使用notify()方法通知等待的线程。
总的来说，这段代码展示了生产者和消费者之间的协作关系，确保生产者不会在产品数量达到上限时继续生产，消费者不会在产品数量为0时继续消费。