Java多线程学习--09

最新推荐文章于 2024-08-03 15:01:05 发布
最新推荐文章于 2024-08-03 15:01:05 发布
阅读量117 收藏
点赞数
分类专栏： Java多线程 文章标签： Java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jja_wangfei/article/details/86256302
版权

说明：参考《Java多线程核心技术》

5、生产者/消费者模式
1、一个生产者一个消费者
public class MyStack {

    private List list = new ArrayList();

    synchronized public void push() {  // push to stack
        try {
            if (list.size() == 1) {  // while
                this.wait();
            }
            list.add("anyString = " + Math.random());
            this.notify();
            System.out.println("push size = " + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public String pop() {   // pop from stack
        String returnValue = "";
        try {
            if (list.size() == 0) {  // while
                System.out.println("pop " + Thread.currentThread().getName() + " is waiting");
                this.wait();
            }
            returnValue = "" + list.get(0);
            list.remove(0);
            this.notify();
            System.out.println("pop size = " + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return returnValue;
    }
}

public class Product {

    private MyStack myStack;

    public Product(MyStack myStack) {
        this.myStack = myStack;
    }

    public void pushService() {
        myStack.push();
    }
}

public class Consume {
    private MyStack myStack;

    public Consume(MyStack myStack) {
        super();
        this.myStack = myStack;
    }

    public void popService() {
        System.out.println("pop = " + myStack.pop());
    }
}

public class ProductThread extends Thread{
    private Product product;

    public ProductThread(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        while (true) {
            product.pushService();
        }
    }
}

public class ConsumeThread extends Thread{
    private Consume consume;

    public ConsumeThread(Consume consume) {
        super();
        this.consume = consume;
    }

    @Override
    public void run() {
        while (true) {
            consume.popService();
        }
    }
}

public class OneProductTest {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        Product product = new Product(myStack);
        Consume consume = new Consume(myStack);
        ProductThread productThread = new ProductThread(product);
        ConsumeThread consumeThread = new ConsumeThread(consume);
        productThread.start();
        consumeThread.start();
    }
}
/**
 push size = 1
 pop = anyString = 0.413003818915496
 pop size = 0
 push size = 1
 pop = anyString = 0.24254707748827975
 pop size = 0
 ...
 */

通过生产者和消费者，容器的size()不会大于1。

2、一个生产者多个消费者
public class MyStack {

    private List list = new ArrayList();

    synchronized public void push() {  // push to stack
        try {
            while (list.size() == 1) {
                this.wait();
            }
            list.add("anyString = " + Math.random());
            this.notifyAll();
            System.out.println("push size = " + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public String pop() {   // pop from stack
        String returnValue = "";
        try {
            while (list.size() == 0) {
                System.out.println("pop " + Thread.currentThread().getName() + " is waiting");
                this.wait();
            }
            returnValue = "" + list.get(0);
            list.remove(0);
            this.notifyAll();
            System.out.println("pop size = " + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return returnValue;
    }
}

public class Product {

    private MyStack myStack;

    public Product(MyStack myStack) {
        this.myStack = myStack;
    }

    public void pushService() {
        myStack.push();
    }
}

public class Consume {
    private MyStack myStack;

    public Consume(MyStack myStack) {
        super();
        this.myStack = myStack;
    }

    public void popService() {
        System.out.println("pop = " + myStack.pop());
    }
}

public class ProductThread extends Thread{
    private Product product;

    public ProductThread(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        while (true) {
            product.pushService();
        }
    }
}

public class ConsumeThread extends Thread{
    private Consume consume;

    public ConsumeThread(Consume consume) {
        super();
        this.consume = consume;
    }

    @Override
    public void run() {
        while (true) {
            consume.popService();
        }
    }
}

public class MultiConsumeTest {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        Product product = new Product(myStack);
        Consume consume= new Consume(myStack);
        Consume consume1 = new Consume(myStack);
        Consume consume2 = new Consume(myStack);

        ProductThread productThread = new ProductThread(product);

        ConsumeThread consumeThread = new ConsumeThread(consume);
        ConsumeThread consumeThread1 = new ConsumeThread(consume1);
        ConsumeThread consumeThread2 = new ConsumeThread(consume2);

        productThread.start();
        consumeThread.start();
        consumeThread1.start();
        consumeThread2.start();
    }
}
/**
 push size = 1
 pop size = 0
 pop = anyString = 0.8524272104911793
 pop Thread-2 is waiting
 push size = 1
 pop size = 0
 pop = anyString = 0.27216364463077425
 pop Thread-3 is waiting
 pop Thread-1 is waiting
 push size = 1
 pop size = 0
 pop = anyString = 0.36276482939085863
 push size = 1
 ...
 */

注意点： 使用while；使用notifyAll();

3、多个生产者一个消费者
public class MyStack {

    private List list = new ArrayList();

    synchronized public void push() {  // push to stack
        try {
            while (list.size() == 1) {
                this.wait();
            }
            list.add("anyString = " + Math.random());
            this.notifyAll();
            System.out.println("push size = " + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public String pop() {   // pop from stack
        String returnValue = "";
        try {
            while (list.size() == 0) {
                System.out.println("pop " + Thread.currentThread().getName() + " is waiting");
                this.wait();
            }
            returnValue = "" + list.get(0);
            list.remove(0);
            this.notifyAll();
            System.out.println("pop size = " + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return returnValue;
    }
}

public class Product {

    private MyStack myStack;

    public Product(MyStack myStack) {
        this.myStack = myStack;
    }

    public void pushService() {
        myStack.push();
    }
}

public class Consume {
    private MyStack myStack;

    public Consume(MyStack myStack) {
        super();
        this.myStack = myStack;
    }

    public void popService() {
        System.out.println("pop = " + myStack.pop());
    }
}

public class ProductThread extends Thread{
    private Product product;

    public ProductThread(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        while (true) {
            product.pushService();
        }
    }
}

public class ConsumeThread extends Thread{
    private Consume consume;

    public ConsumeThread(Consume consume) {
        super();
        this.consume = consume;
    }

    @Override
    public void run() {
        while (true) {
            consume.popService();
        }
    }
}

public class MultiConsumeTest {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        Product product = new Product(myStack);
        Consume consume= new Consume(myStack);
        Consume consume1 = new Consume(myStack);
        Consume consume2 = new Consume(myStack);

        ProductThread productThread = new ProductThread(product);

        ConsumeThread consumeThread = new ConsumeThread(consume);
        ConsumeThread consumeThread1 = new ConsumeThread(consume1);
        ConsumeThread consumeThread2 = new ConsumeThread(consume2);

        productThread.start();
        consumeThread.start();
        consumeThread1.start();
        consumeThread2.start();
    }
}
/**
 push size = 1
 pop size = 0
 pop = anyString = 0.8524272104911793
 pop Thread-2 is waiting
 push size = 1
 pop size = 0
 pop = anyString = 0.27216364463077425
 pop Thread-3 is waiting
 pop Thread-1 is waiting
 push size = 1
 pop size = 0
 pop = anyString = 0.36276482939085863
 push size = 1
 ...
 */

注意点： 使用while；使用notifyAll();

4、多个生产者一个消费者
public class MyStack {

    private List list = new ArrayList();

    synchronized public void push() {  // push to stack
        try {
            while (list.size() == 1) {
                this.wait();
            }
            list.add("anyString = " + Math.random());
            this.notifyAll();
            System.out.println("push size = " + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public String pop() {   // pop from stack
        String returnValue = "";
        try {
            while (list.size() == 0) {
                System.out.println("pop " + Thread.currentThread().getName() + " is waiting");
                this.wait();
            }
            returnValue = "" + list.get(0);
            list.remove(0);
            this.notifyAll();
            System.out.println("pop size = " + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return returnValue;
    }
}

public class Product {

    private MyStack myStack;

    public Product(MyStack myStack) {
        this.myStack = myStack;
    }

    public void pushService() {
        myStack.push();
    }
}

public class Consume {
    private MyStack myStack;

    public Consume(MyStack myStack) {
        super();
        this.myStack = myStack;
    }

    public void popService() {
        System.out.println("pop = " + myStack.pop());
    }
}

public class ProductThread extends Thread{
    private Product product;

    public ProductThread(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        while (true) {
            product.pushService();
        }
    }
}

public class ConsumeThread extends Thread{
    private Consume consume;

    public ConsumeThread(Consume consume) {
        super();
        this.consume = consume;
    }

    @Override
    public void run() {
        while (true) {
            consume.popService();
        }
    }
}

public class MultiProductTest {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();

        Product product = new Product(myStack);
        Product product1 = new Product(myStack);
        Product product2 = new Product(myStack);

        ProductThread productThread = new ProductThread(product);
        ProductThread productThread1 = new ProductThread(product1);
        ProductThread productThread2 = new ProductThread(product2);

        productThread.start();
        productThread1.start();
        productThread2.start();

        Consume consume = new Consume(myStack);
        ConsumeThread consumeThread = new ConsumeThread(consume);
        consumeThread.start();

    }
}
/**
 push size = 1
 pop size = 0
 pop = anyString = 0.7074313942678033
 pop Thread-3 is waiting
 push size = 1
 pop size = 0
 pop = anyString = 0.9030921643856575
 pop Thread-3 is waiting
 push size = 1
 pop size = 0
 pop = anyString = 0.051652492487380686
 pop Thread-3 is waiting
 push size = 1
 pop size = 0
 pop = anyString = 0.9269650225595099
 pop Thread-3 is waiting
 ...
 */
5、多个生产者对多个消费者
public class MyStack {

    private List list = new ArrayList();

    synchronized public void push() {  // push to stack
        try {
            while (list.size() == 1) {
                this.wait();
            }
            list.add("anyString = " + Math.random());
            this.notifyAll();
            System.out.println("push size = " + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public String pop() {   // pop from stack
        String returnValue = "";
        try {
            while (list.size() == 0) {
                System.out.println("pop " + Thread.currentThread().getName() + " is waiting");
                this.wait();
            }
            returnValue = "" + list.get(0);
            list.remove(0);
            this.notifyAll();
            System.out.println("pop size = " + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return returnValue;
    }
}

public class Product {

    private MyStack myStack;

    public Product(MyStack myStack) {
        this.myStack = myStack;
    }

    public void pushService() {
        myStack.push();
    }
}

public class Consume {
    private MyStack myStack;

    public Consume(MyStack myStack) {
        super();
        this.myStack = myStack;
    }

    public void popService() {
        System.out.println("pop = " + myStack.pop());
    }
}

public class ProductThread extends Thread{
    private Product product;

    public ProductThread(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        while (true) {
            product.pushService();
        }
    }
}

public class ConsumeThread extends Thread{
    private Consume consume;

    public ConsumeThread(Consume consume) {
        super();
        this.consume = consume;
    }

    @Override
    public void run() {
        while (true) {
            consume.popService();
        }
    }
}

public class MultiConsumeTest {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();

        Product product = new Product(myStack);
        Product product1 = new Product(myStack);
        Product product2 = new Product(myStack);

        Consume consume= new Consume(myStack);
        Consume consume1 = new Consume(myStack);
        Consume consume2 = new Consume(myStack);

        ProductThread productThread = new ProductThread(product);
        ProductThread productThread1 = new ProductThread(product1);
        ProductThread productThread2 = new ProductThread(product2);

        ConsumeThread consumeThread = new ConsumeThread(consume);
        ConsumeThread consumeThread1 = new ConsumeThread(consume1);
        ConsumeThread consumeThread2 = new ConsumeThread(consume2);

        productThread.start();
        productThread1.start();
        productThread2.start();


        consumeThread.start();
        consumeThread1.start();
        consumeThread2.start();
    }
}
/**
 push size = 1
 pop size = 0
 pop = anyString = 0.877645574289827
 pop Thread-5 is waiting
 push size = 1
 pop size = 0
 pop = anyString = 0.4771502604337374
 push size = 1
 pop size = 0
 push size = 1
 pop = anyString = 0.6845739056478685
 pop size = 0
 pop = anyString = 0.5083075161836528
 pop Thread-3 is waiting
 ...
 */
泡椒酱的java学习记录
关注
专栏目录
Java多线程基础-01、数组概述.rar
11-20
总的来说，"Java多线程基础-01、数组概述"的学习将帮助你理解如何在Java中创建和管理线程，以及如何在多线程环境下安全地使用数组。通过深入学习这部分内容，你将具备编写高效并发程序的基础，为后续的多线程编程...
WHUT-java多线程实验-第二周-异常处理.zip
01-16
在"WHUT-java多线程实验-第二周-异常处理"这个实验中，我们将学习如何在多线程环境下进行异常捕获和处理。实验基于IntelliJ IDEA这个强大的Java集成开发环境进行，IDEA提供了友好的界面和丰富的工具，方便我们进行...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
qq_35716689的博客
03-16 25万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
qq_35716689的博客
03-25 24万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
Java多线程实战-CountDownLatch模拟压测实现
qq_35716689的博客
03-17 25万+
当多个线程需要协调和同步执行任务时，Java 中的 CountDownLatch（倒计时器）是一个常用的工具类。它可以帮助开发者实现线程之间的同步，确保某些线程在其他线程完成任务后再继续执行。牵着猫散步的鼠鼠。本文将介绍 CountDownLatch 的基本原理、用法以及示例代码，最后会使用CountDownLatch完成一个简单的压测实现。
Java多线程-----定时器（Timer）及其实现
2302_79862386的博客
08-03 2074
Java多线程-----定时器（Timer）及其实现
Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
qq_35716689的博客
03-20 25万+
CompletableFuture为Java提供了强大的异步编程能力,可以极大地提高应用的并发能力和响应速度。通过并行执行多个查询任务,我们可以大幅减少接口的响应时间,优化用户体验。同时,CompletableFuture的代码风格函数式、简洁、优雅,也使得代码更加易读易维护。 但是,异步编程也不是万能的,它需要开发者转变思维模式,还需要权衡利弊。在实际项目中,我们可以结合其他优化手段,选择合适的方案,以达到最佳的性能效果。
Java多线程实战-从零手搓一个简易线程池(二)线程池实现与拒绝策略接口定义
qq_35716689的博客
03-27 24万+
在前面的文章中，我们讲解了任务堵塞队列的实现，这篇文章会基于任务堵塞队列实现一个简易的线程池，在后续的文章中，还会继续对本章编写的线程池进行功能扩展和优化。
Java多线程-----线程安全问题（详解）
2302_79862386的博客
07-20 2768
Java多线程-----线程安全问题（详解）
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java多线线程-----等待唤醒机制(wait notify)
2302_79862386的博客
07-25 8205
Java多线线程-----等待唤醒机制(wait notify)
Java多线程学习Java多线程学习Java多线程学习Java多线程学习.txt
05-15
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java...
基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip
01-08
基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip 基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip 基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码....
java多线程tcpsocketserver源码-Java-Book:Java学习资料整理
06-05
java多线程tcp socket server源码 Java学习资料整理 框架 / dubbo监控 / / / / / / / / / / / / / / / / / / / / 收藏 / 技术社区 书籍推荐 计算机基础 计算机科学导论 --(如果不是计算机科班的，应先看看计算机基础...
用于项目样式reset的资源
11-03
用于项目样式reset的资源
pytz-2016.10.tar.bz2
最新发布
11-03
pytz库的主要功能 时区转换：pytz库允许用户将时间从一个时区转换到另一个时区，这对于处理跨国业务或需要处理多地时间的数据分析尤为重要。 历史时区数据支持：pytz库不仅提供了当前的时区数据，还包含了历史上不同时期的时区信息，这使得它在处理历史数据时具有无与伦比的优势。 夏令时处理：pytz库能够自动处理夏令时的变化，当获取某个时区的时间时，它会自动考虑是否处于夏令时期间。 与datetime模块集成：pytz库可以与Python标准库中的datetime模块一起使用，以确保在涉及不同时区的场景中时间的准确性。
VB程序实例-判断键盘按下的键值.zip
11-03
VB程序实例-判断键盘按下的键值.zip
VB程序实例-控制其他程序成为自己的子窗体.zip
11-03
VB程序实例-控制其他程序成为自己的子窗体.zip
Java多线程编程-安徽大学计算机科学与技术学院教程
"Java多线程是Java语言程序设计中的一个重要概念，它允许程序同时执行多个任务，提高程序的效率和响应性。Java从语言层面支持多线程，这意味着它的类库和API都是以多线程思维设计的，使得开发者能够方便地创建和管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值