P139-多线程-线程间的通信机制与生产者消费者案例

最新推荐文章于 2024-07-27 17:56:15 发布

爱吃炫迈的绮绮

最新推荐文章于 2024-07-27 17:56:15 发布

阅读量150

点赞数 1

文章标签： java 算法 jvm

本文链接：https://blog.csdn.net/aichixuanmai/article/details/136634867

版权

package cd_one.code12.Exer11;
class PrintNumber implements Runnable{
    private int number = 1;
    @Override
    public void run() {
        while(true){
            synchronized (this) {
                if(number <= 100){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()
                            + ":" + number);
                    number++;
                }else{
                    break;
                }
            }
        }
    }
}
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();

    }

}

线程1:1
线程1:2
线程1:3
线程1:4
线程1:5
线程1:6
线程1:7
线程1:8
线程1:9
线程1:10
线程1:11
线程1:12
线程1:13
线程1:14
线程1:15
线程1:16
线程1:17
线程1:18
线程1:19
线程1:20
线程1:21
线程1:22
线程1:23
线程1:24
线程1:25
线程1:26
线程1:27
线程1:28
线程1:29
线程1:30
线程1:31
线程1:32
线程1:33
线程1:34
线程1:35
线程2:36
线程2:37
线程2:38
线程1:39
线程1:40
线程1:41
线程1:42
线程1:43
线程1:44
线程1:45
线程1:46
线程1:47
线程1:48
线程1:49
线程1:50
线程1:51
线程1:52
线程1:53
线程1:54
线程1:55
线程1:56
线程1:57
线程1:58
线程1:59
线程1:60
线程1:61
线程1:62
线程1:63
线程1:64
线程1:65
线程1:66
线程1:67
线程1:68
线程1:69
线程1:70
线程1:71
线程1:72
线程1:73
线程1:74
线程2:75
线程1:76
线程1:77
线程1:78
线程1:79
线程1:80
线程2:81
线程2:82
线程2:83
线程2:84
线程2:85
线程2:86
线程2:87
线程1:88
线程1:89
线程2:90
线程2:91
线程2:92
线程2:93
线程1:94
线程1:95
线程1:96
线程1:97
线程2:98
线程2:99
线程2:100

使两个线程交替打印

package cd_one.code12.Exer11;
class PrintNumber implements Runnable{
    private int number = 1;
    @Override
    public void run() {
        while(true){
            synchronized (this) {
                if(number <= 100){
                    notify();
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()
                            + ":" + number);
                    number++;
                    try {
                        wait();//线程一单进入此方法，则进入等待状态，会释放对同步监视器的调用
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}
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();

    }

}

package cd_one.code12.Exer11;
class PrintNumber implements Runnable{
    private int number = 1;
    Object obj = new Object();
    @Override
    public void run() {
        while(true){
            synchronized (obj) {
                if(number <= 100){
                    obj.notify();
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()
                            + ":" + number);
                    number++;
                    try {
                        obj.wait();//线程一单进入此方法，则进入等待状态，会释放对同步监视器的调用
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}
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();

    }

}

package cd_one.code12.Exer12;

/**
 * 分析：
 * 1.是否是多线程问题？是，生产者，消费者
 * 2.是否有共享数据？有！共享数据是：产品
 * 3.是否有线程安全问题？有！因为有共享数据
 * 4.是否需要处理线程安全问题？是！如何处理，使用同步机制
 * 5.是否存在线程间的通信？存在。
 */
class Clerk{//店员
private  int productionNum = 0;
//增加
    public synchronized void addProduct(){
        if(productionNum >= 20){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            productionNum++;
            System.out.println(Thread.currentThread().getName() +
                    "生产了第" + productionNum + "个产品");
            //唤醒
            notifyAll();
        }

    }
    //减少
    public synchronized void minusProduct(){
        if(productionNum <= 0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            System.out.println(Thread.currentThread().getName() +
                    "消费了第" + productionNum + "个产品");
            productionNum--;

            notifyAll();
        }

    }
}
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);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            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(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.minusProduct();
        }
    }
}
public class ProducerConsumerTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer pro1 = new Producer(clerk);
        Consumer con1 = new Consumer(clerk);
        pro1.setName("生产者1");
        con1.setName("消费者1");
        pro1.start();
        con1.start();
    }
}

生产者开始生产产品...
生产者1生产了第2个产品
生产者开始生产产品...
消费者1消费了第2个产品
消费者开始消费产品...
生产者1生产了第2个产品
生产者开始生产产品...
消费者1消费了第2个产品
消费者开始消费产品...
消费者1消费了第1个产品
消费者开始消费产品...
生产者1生产了第1个产品
生产者开始生产产品...
消费者1消费了第1个产品
消费者开始消费产品...
生产者1生产了第1个产品
生产者开始生产产品...
消费者1消费了第1个产品
消费者开始消费产品...
生产者1生产了第1个产品
生产者开始生产产品...
消费者1消费了第1个产品
消费者开始消费产品...
生产者1生产了第1个产品
生产者开始生产产品...
生产者1生产了第2个产品
生产者开始生产产品...
消费者1消费了第2个产品
消费者开始消费产品...
消费者1消费了第1个产品
消费者开始消费产品...
生产者1生产了第1个产品
生产者开始生产产品...
消费者1消费了第1个产品
消费者开始消费产品...
生产者1生产了第1个产品
生产者开始生产产品...
生产者1生产了第2个产品