[学习笔记]Java多线程经典问题

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

生产者消费者问题

描述

有一群生产者在生产产品，并将这些产品提供给消费者去消费。为使生产者与消费者能够并发执行，在两者之间设置一个具有 n 个缓冲区的缓冲池，生产者将他所生产的产品放入一个缓冲区中；消费者可从一个缓冲区中取走产品去消费。尽管所有的生产者和消费者都是以异步方式运行，但他们之间必须保持同步，即不允许消费者到一个空缓冲区去取产品；也不允许生产者向一个已装满产品且尚未被取走的缓冲区投放产品。
假设缓冲区为100。

思路

1. 生产者和消费者都有两个状态，生产/消费和等待。
2. 共享资源就是库存，生产者生产产品放入缓冲区（库存增加），消费者消费缓冲区中的产品（库存减少）。
3. 生产者生产产品影响消费者消费（有产品可以消费了），消费者消费产品影响生产者（库存空了可以生产了）。

步骤

1. 设计3个类，一个资源类，一个生产者类，一个消费者类。

资源类
  |--（常量）产品仓库大小（缓冲区）
  |--（变量）产品仓库
  |--（变量）生产的产品编号
  |--（变量）消费的产品编号
  |--（变量）库存
  |--（变量）锁
  |--（变量）锁上2个监视器，分别对于生产者和消费者
  |--（变量）运行标志
  |--（方法）仓库是否已满
  |--（方法）仓库是否已空
  |--（方法）是否正在运行（返回运行标志）
  |--（方法）终止程序运行
  |--（方法）生产
  |--（方法）消费

生产者类
  |--（变量）资源对象
  |--（方法）循环生产

消费者类
  |--（变量）资源对象
  |--（方法）循环消费

2. 生产前判断仓库是否已满，如果已满则等待，不满则生产，并唤醒消费者。
3. 消费前判断仓库是否已空，如果已空则等待，不空则消费，并唤醒生产者。

程序

   
   

    
    

     
     import java.util.concurrent.locks.ReentrantLock;
    
    

    
    

     
     import java.util.concurrent.locks.Lock;
    
    

    
    

     
     import java.util.concurrent.locks.Condition;
    
    

    
    

     
      
    
    

    
    

     
     class Resource {
    
    

    
    

     
       public static final int MAX = 100;
    
    

    
    

     
       private int front = 0; // 生产的产品编号，生产一个就加1，并打印。
    
    

    
    

     
       private int rear = 0; // 消费的产品编号，消费一个就加1，并打印。
    
    

    
    

     
       private int count = 0; // 仓库中产品的数量。
    
    

    
    

     
      
    
    

    
    

     
       private final Object[] items = new Object[ MAX];
    
    

    
    

     
       private boolean runflag = true;
    
    

    
    

     
      
    
    

    
    

     
       private final Lock lock = new ReentrantLock();
    
    

    
    

     
       private final Condition notFull = lock.newCondition();
    
    

    
    

     
       private final Condition notEmpty = lock.newCondition();
    
    

    
    

     
      
    
    

    
    

     
       public boolean isFull() // 判断仓库是否满
    
    

    
    

     
       {
    
    

    
    

     
         return ( count == items. length);
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       public boolean isEmpty() // 判断仓库是否空
    
    

    
    

     
       {
    
    

    
    

     
         return ( count == 0);
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       public boolean isRunnable() // 生产和消费是否可执行
    
    

    
    

     
       {
    
    

    
    

     
         return runflag;
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       public void stopRun() // 终止生产和消费
    
    

    
    

     
       {
    
    

    
    

     
         runflag = false;
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       public void put(Object x) // 生产函数
    
    

    
    

     
       {
    
    

    
    

     
         lock.lock();
    
    

    
    

     
         try {
    
    

    
    

     
           while (isFull()) { // 如果仓库已满，则生产（仓库非满）等待。
    
    

    
    

     
             System.out.println(Thread.currentThread().getName() + " wait!");
    
    

    
    

     
             try {
    
    

    
    

     
               notFull.await();
    
    

    
    

     
             } catch (InterruptedException e) {} // 暂时不做异常处理
    
    

    
    

     
           }
    
    

    
    

     
           items[front] = x;
    
    

    
    

     
           System.out.println(Thread. currentThread().getName() + "...生产 = " + front + "...库存 = "
    
    

    
    

     
               + ++ count); // 显示线程，生产/消费，指针以及库存。
    
    

    
    

     
           front = (front + 1) % MAX; // 当指针到数组边界后从头开始循环。
    
    

    
    

     
           notEmpty.signal(); // 已经生产出产品，唤醒消费者（仓库非空）。
    
    

    
    

     
         } finally {
    
    

    
    

     
           lock.unlock(); // 锁的释放是必要行为，所以放在 finally 语句中。
    
    

    
    

     
         }
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       public Object take() // 消费函数
    
    

    
    

     
       {
    
    

    
    

     
         lock.lock();
    
    

    
    

     
         try {
    
    

    
    

     
           // 这里只能使用while而不能使用 if-else 组合，因为 return 语句必须在 try 中，而不可以在 else 中。
    
    

    
    

     
           while (isEmpty()) { // 如果仓库已空，则消费（仓库非空）等待。
    
    

    
    

     
             System.out.println(Thread.currentThread().getName() + " wait!");
    
    

    
    

     
             try {
    
    

    
    

     
               notEmpty.await();
    
    

    
    

     
             } catch (InterruptedException e) {} // 暂时不做异常处理
    
    

    
    

     
           }
    
    

    
    

     
           Object x = items[rear]; // 将指针指向的元素拿出。
    
    

    
    

     
           System.out.println(Thread. currentThread().getName() + "...消费 = " + rear + "...库存 = "
    
    

    
    

     
               + -- count); // 显示线程，生产/消费，指针以及库存。
    
    

    
    

     
           rear = (rear + 1) % MAX;
    
    

    
    

     
           notFull.signal();
    
    

    
    

     
           return x; // 将拿出的元素给消费者消费。
    
    

    
    

     
         } finally {
    
    

    
    

     
           lock.unlock();
    
    

    
    

     
         }
    
    

    
    

     
       }
    
    

    
    

     
     }
    
    

    
    

     
      
    
    

    
    

     
      
    
    

    
    

     
     class Producer implements Runnable {
    
    

    
    

     
       private Resource r;
    
    

    
    

     
      
    
    

    
    

     
       public Producer(Resource r) // 将公共的资源（仓库）传入构造函数
    
    

    
    

     
       {
    
    

    
    

     
         this.r = r;
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       public void run() {
    
    

    
    

     
         while ( r.isRunnable()) // 当生产消费可执行时开始生产
    
    

    
    

     
         {
    
    

    
    

     
           r.put(new Object());
    
    

    
    

     
         }
    
    

    
    

     
       }
    
    

    
    

     
     }
    
    

    
    

     
      
    
    

    
    

     
     class Consumer implements Runnable {
    
    

    
    

     
       private Resource r;
    
    

    
    

     
      
    
    

    
    

     
       public Consumer(Resource r) {
    
    

    
    

     
         this.r = r;
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       public void run() {
    
    

    
    

     
         while ( r.isRunnable()) {
    
    

    
    

     
           r.take();
    
    

    
    

     
         }
    
    

    
    

     
       }
    
    

    
    

     
     }
    
    

    
    

     
      
    
    

    
    

     
     public class ThreadProducerConsumer {
    
    

    
    

     
       public static void main(String[] args) {
    
    

    
    

     
         Resource r = new Resource();
    
    

    
    

     
         Producer p = new Producer( r);
    
    

    
    

     
         Consumer c = new Consumer( r);
    
    

    
    

     
         new Thread( p).start();
    
    

    
    

     
         new Thread( p).start();
    
    

    
    

     
         new Thread( c).start();
    
    

    
    

     
         new Thread( c).start();
    
    

    
    

     
         // 生产消费执行3秒后停止
    
    

    
    

     
         try {
    
    

    
    

     
           Thread.sleep(3000);
    
    

    
    

     
         } catch (InterruptedException e) { /* TODO：处理代码 */}
    
    

    
    

     
         r.stopRun();
    
    

    
    

     
       }
    
    

    
    

     
     }

运行结果（部分）

Thread-1...生产 = 88...库存 = 96
Thread-1...生产 = 89...库存 = 97
Thread-1...生产 = 90...库存 = 98
Thread-1...生产 = 91...库存 = 99
Thread-1...生产 = 92...库存 = 100
Thread-1 wait!
Thread-0 wait!
Thread-3...消费 = 93...库存 = 99
Thread-3...消费 = 94...库存 = 98
Thread-3...消费 = 95...库存 = 97
Thread-3...消费 = 96...库存 = 96

哲学家进餐问题

描述

五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五只筷子，他们的生活方式是交替地进行思考和进餐。平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的筷子，只有在他拿到两只筷子时才能进餐。进餐毕，放下筷子继续思考。

思路

1. 哲学家共有两个状态：思考和进餐。只有进餐用到临界资源：筷子。
2. 哲学家使用临界资源有两个方法：使用筷子，放弃筷子，分别对应哲学家两个状态。
3. 哲学家使用筷子始终影响的是邻座的两个哲学家。

步骤

1. 设计两个类，一个筷子类，一个哲学家类。

筷子类
  |--（变量）5只筷子
  |--（变量）锁
  |--（变量）锁上5个监视器方法，分别对应5个哲学家
  |--（方法）思考
  |--（方法）进餐

哲学家类
  |--（变量）筷子类资源
  |--（变量）哲学家编号
  |--（变量）哲学家工作标志
  |--（方法）哲学家工作：包含思考和进餐
  |--（方法）哲学家停止工作
  |--（方法）run方法：条件循环执行工作方法。

2. 当哲学家进餐，则判断左右两只筷子是否被占用，如果没有，则标记这两只筷子使用，哲学家进餐，进餐人数加1；如果筷子被占用，则哲学家等待。
3. 当哲学家思考，则将左右两只筷子标记未使用，进餐人数减1，唤醒左边和右边两个哲学家。
4. 当哲学家停止工作，那么工作标记将被复位，哲学家工作循环停止。

程序

   
   

    
    

     
     import java.util.concurrent.locks.ReentrantLock;
    
    

    
    

     
     import java.util.concurrent.locks.Lock;
    
    

    
    

     
     import java.util.concurrent.locks.Condition;
    
    

    
    

     
      
    
    

    
    

     
     class Chopsticks {
    
    

    
    

     
       // 5只筷子使用标记
    
    

    
    

     
       private boolean[] chops = {false, false, false, false, false};
    
    

    
    

     
       private int eatcount = 0; // 进餐人数统计
    
    

    
    

     
       private final Lock lock = new ReentrantLock();
    
    

    
    

     
       private final Condition[] ph_monitor = new Condition[5];
    
    

    
    

     
       {
    
    

    
    

     
         for (int i = 0; i < 5; i++) {
    
    

    
    

     
           // 初始化代码块，初始化针对5个哲学家监视器类
    
    

    
    

     
           ph_monitor[i] = lock.newCondition();
    
    

    
    

     
         }
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       public void eat( int ph) {
    
    

    
    

     
         lock.lock();
    
    

    
    

     
         try {
    
    

    
    

     
           // 如果左右两只筷子在用，那么该哲学家等待
    
    

    
    

     
           while ( chops[ ph] || chops[( ph + 1) % 5]) {
    
    

    
    

     
             System. out.println("PH." + ph + " Waiting..." );
    
    

    
    

     
             try {
    
    

    
    

     
               ph_monitor[ ph].await();
    
    

    
    

     
             } catch (InterruptedException e) {}
    
    

    
    

     
           }
    
    

    
    

     
           // 左右两只筷子未用，则拿起筷子进餐
    
    

    
    

     
           chops[ph] = true;
    
    

    
    

     
           chops[(ph + 1) % 5] = true;
    
    

    
    

     
           eatcount++;
    
    

    
    

     
           System.out.println( "PH." + ph + "......Eating\tCount = " + eatcount );
    
    

    
    

     
         } finally {
    
    

    
    

     
           lock.unlock();
    
    

    
    

     
         }
    
    

    
    

     
         try {
    
    

    
    

     
           Thread.sleep(5);
    
    

    
    

     
         } catch (InterruptedException e) { /* TODO：处理代码 */}
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       public void think( int ph) {
    
    

    
    

     
         lock.lock();
    
    

    
    

     
         try {
    
    

    
    

     
           // 哲学家转为思考，则放弃左右两只筷子，并唤醒左右两个哲学家。
    
    

    
    

     
           chops[ph] = false;
    
    

    
    

     
           chops[(ph + 1) % 5] = false;
    
    

    
    

     
           ph_monitor[(ph + 1) % 5].signal();
    
    

    
    

     
           ph_monitor[(ph + 4) % 5].signal();
    
    

    
    

     
           eatcount--; // 进餐人数减1
    
    

    
    

     
           System.out.println( "PH." + ph + "......Thinking\tCount = " + eatcount );
    
    

    
    

     
         } finally {
    
    

    
    

     
           lock.unlock();
    
    

    
    

     
         }
    
    

    
    

     
         try {
    
    

    
    

     
           Thread.sleep(5);
    
    

    
    

     
         } catch (InterruptedException e) { /* TODO：处理代码 */}
    
    

    
    

     
       }
    
    

    
    

     
     }
    
    

    
    

     
      
    
    

    
    

     
      
    
    

    
    

     
     class Philosopher implements Runnable {
    
    

    
    

     
       private int ph = 0;
    
    

    
    

     
       private Chopsticks ch;
    
    

    
    

     
       private boolean runflag = true; // 工作标志，false表示哲学家停止工作
    
    

    
    

     
      
    
    

    
    

     
       Philosopher(int ph, Chopsticks ch) {
    
    

    
    

     
         this.ph = ph;
    
    

    
    

     
         this.ch = ch;
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       private void work() {
    
    

    
    

     
         // 哲学家工作，包含进餐和思考，并严格交替执行
    
    

    
    

     
         ch.eat(ph);
    
    

    
    

     
         ch.think(ph);
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       public void run() {
    
    

    
    

     
         while ( runflag) {
    
    

    
    

     
           // 判断工作标志，工作标志为true时，不停工作
    
    

    
    

     
           work();
    
    

    
    

     
         }
    
    

    
    

     
       }
    
    

    
    

     
      
    
    

    
    

     
       public void stopRun() {
    
    

    
    

     
         runflag = false;
    
    

    
    

     
       }
    
    

    
    

     
     }
    
    

    
    

     
      
    
    

    
    

     
      
    
    

    
    

     
     public class ThreadDpp {
    
    

    
    

     
       public static void main(String[] args) {
    
    

    
    

     
         final Chopsticks ch = new Chopsticks();
    
    

    
    

     
         Philosopher ph[] = new Philosopher[5];
    
    

    
    

     
         Thread t[] = new Thread[5];
    
    

    
    

     
         for (int i = 0; i < 5; i++) {
    
    

    
    

     
           ph[i] = new Philosopher( i, ch);
    
    

    
    

     
           t[i] = new Thread( ph[ i]);
    
    

    
    

     
           t[i].start();
    
    

    
    

     
         }
    
    

    
    

     
         // 哲学家工作3秒后停止
    
    

    
    

     
         try {
    
    

    
    

     
           Thread.sleep(3000);
    
    

    
    

     
         } catch (InterruptedException e) { /* TODO：处理代码 */}
    
    

    
    

     
         for (int i = 0; i < 5; i++) {
    
    

    
    

     
           ph[i].stopRun();
    
    

    
    

     
         }
    
    

    
    

     
       }
    
    

    
    

     
     }

运行结果（部分）

PH.0......Eating   Count = 1
PH.1 Waiting...
PH.2......Eating   Count = 2
PH.3 Waiting...
PH.4 Waiting...
PH.2......Thinking Count = 1
PH.3......Eating   Count = 2
PH.1 Waiting...
PH.0......Thinking Count = 1
PH.1......Eating   Count = 2
PH.4 Waiting...
PH.3......Thinking Count = 1
PH.0 Waiting...
PH.4......Eating   Count = 2
PH.1......Thinking Count = 1
PH.2......Eating   Count = 2
PH.0 Waiting...
PH.3 Waiting...
PH.2......Thinking Count = 1
PH.4......Thinking Count = 0

Dark_Tomcat
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC学习笔记（Java多线程）
07-04
总的来说，JUC学习笔记涵盖了Java多线程编程的主要方面，包括线程的创建与管理、同步机制、并发容器以及协调工具的使用，这些都是提升Java并发编程能力的关键知识点。通过深入理解和熟练应用这些工具，开发者可以更...
java分布式应用学习笔记05多线程下的并发同步器.pdf
11-29
在Java分布式应用开发中，多线程环境下的并发同步是至关重要的一个环节。并发同步器在多线程编程中起到协调各个线程访问共享资源，确保数据一致性与程序正确性的关键作用。本篇笔记将深入探讨Java中的并发同步机制，...
java中execquery()_JACOB库在多线程中使用时失败
weixin_42709044的博客
02-28 527
我有一个奇怪的问题，使用来自两个相应启动的相同线程的JACOB。我有一个实用程序类，它使用静态ActiveXObject字段将各种请求分发给WMI。第一个线程正常工作。当第二个线程开始我得到以下异常：JACOB库在多线程中使用时失败com.jacob.com.ComFailException: Can't map name to dispid: ExecQueryat com.jacob.com....
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 20万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3268
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
尚硅谷_java多线程_学习笔记
qq_17079255的博客
10-08 936
文章标题
Java学习笔记-多线程
cyh0503的博客
07-08 2814
并发与并行 并发：指两个或多个事件在同一个时间段内发生 并行：指两个或多个事件在同一时刻发生（同时发生） 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 而在多个CPU系统中，则这些可以并发执行的程序便可以分配到多...
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
最新发布
qq_35716689的博客
03-16 20万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
学习笔记：多线程Java Socket编程示例
08-17
在本学习笔记中，我们将探讨如何使用Java的Socket编程实现多线程服务器，特别是通过ExecutorService创建线程池来处理客户端的并发请求。ExecutorService是一个高级的线程管理工具，它允许我们更有效地管理和控制线程...
黑马程序员–Java多线程讲解笔记
12-22
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景以及Java中创建线程的两种方式。 首先，进程和线程是理解多线程的基础概念...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java多线程笔记详解
you are sherlocked by me!
10-09 545
这是学习多线程知识的学习笔记，大家可以选择自己感兴趣的部分阅读学习 详细代码见github代码   Java多线程学习笔记1之多线程基础 内容: 1) 基本概念以及线程的实现方法   Java多线程学习笔记2之多线程基础 内容: 1) 数据同步 2) 非线程安全情况以及处理方法 3) Java内存模型 4) Thread.currentThread()抽象方法使用 ...
解决jacob调用word处理doc文件的内存溢出问题
技不如人
04-21 8802
背景： 有个项目在系统后台用Jacob调用WORDjin
Java多线程学习笔记：线程状态与同步机制
"这篇学习笔记主要探讨了多线程的概念、创建与启动方式、线程方法、线程的生命周期及状态、系统锁synchronized的使用和特性，包括可重入锁和锁升级机制。" 在Java编程中，多线程是一项重要的并发处理技术，它允许...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值