学习笔记5(模拟3个经典多线程问题)

最新推荐文章于 2023-04-21 01:07:08 发布
最新推荐文章于 2023-04-21 01:07:08 发布
阅读量202 收藏 1
点赞数
文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44237327/article/details/106976793
版权

多线程3个实例

利用信号量解决以下3个经典多线程问题
分别为
生产者-消费者问题
写者-读者问题
哲学家就餐问题

生产者-消费者

假定在生产者和消费者之间的公用缓冲区中具有n个缓冲区，这时可利用互斥信号量mutex实现诸进程对缓冲区的互斥使用：利用信号量empty和full分别表示缓冲池中空缓冲区和满缓冲区的数量。又假定这些生产者和消费者相互等效，只要缓冲池未满，生产者便可将任务送入缓冲区，只要缓冲池未空，消费者便可从缓冲区中取走一个任务。
主体思路就是设置3个信号量，分别代表缓冲区满，缓冲区空和互斥信号量
当生产者请求生产时，先判断缓冲区是否已满，再申请互斥信号量，生产后先释放互斥信号量，再释放full信号量
同样的，消费者在消费时，也是先判断缓冲区是否为空，再申请互斥信号量，消费后先释放互斥信号量，再释放empty信号量
下面展示一些代码。

package MultiThreading;

import java.util.LinkedList;
import java.util.concurrent.Semaphore;

class Producer implements Runnable{
    private ProducerAndConsumer pc;
    private String name;
 //-------------构造函数--------------------
    public Producer(){}
    public Producer(ProducerAndConsumer pc , String name){
        this.pc = pc;
        this.name = name;
    }
 //----------------------------------------
    public void run(){
        while(true){
            try{
                Thread.sleep(500);
                pc.produce(name);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}


class Consumer implements Runnable{
    private ProducerAndConsumer pc;
    private String name;
//-------------构造函数--------------------
    public Consumer(){}
    public Consumer(ProducerAndConsumer pc , String name){
        this.pc = pc;
        this.name = name;
    }
//----------------------------------------
    public void run(){
        while(true){
            try{
                Thread.sleep(3000);
                pc.consume(name);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}



public class ProducerAndConsumer {
	    private LinkedList<Object> list = new LinkedList<Object>();
	    private Semaphore mutex = new Semaphore(1);
	    private Semaphore empty = new Semaphore(15);
	    private Semaphore full = new Semaphore(0);

	    public void produce(String s)
	    {
	        try {
	            empty.acquire();
	            mutex.acquire();
	            list.add(new Object());
	            System.out.println( s + "向缓冲区生产一个任务，缓冲区当前任务数" + list.size());
	            mutex.release();
	            full.release();
	        }
	        catch (Exception e) {
	            e.printStackTrace();
	        }
	    }

	    public void consume(String s)
	    {
	        try {
	            full.acquire();
	            mutex.acquire();
	            list.remove();
	            System.out.println( s + "从缓冲区消费一个任务，缓冲区当前任务数" + list.size());
	            mutex.release();
	            empty.release();
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	    }

	public static void main(String[] args) {
		ProducerAndConsumer pc = new  ProducerAndConsumer(); 
        Thread p1 = new Thread(new Producer(pc,"生产者1号"));
        Thread p2 = new Thread(new Producer(pc,"生产者2号"));
        Thread c1 = new Thread(new Consumer(pc,"消费者1号"));
        Thread c2 = new Thread(new Consumer(pc,"消费者2号"));
        Thread c3 = new Thread(new Consumer(pc,"消费者3号"));
        Thread c4 = new Thread(new Consumer(pc,"消费者4号"));
        Thread c5 = new Thread(new Consumer(pc,"消费者5号"));

        c1.start();
        c2.start();
        c3.start();
        c4.start();
        c5.start();
        p1.start();
        p2.start();

	}

}

读者-写者

一个数据文件或记录可被多个进程共享，我们把只要求该读文件的进程称为“Reader进程”，其他进程则称为“Writer进程”。允许多个进程同时读一个共享对象，因为读操作不会使数据文件混乱。但不允许一个Writer进程和Reader进程或Writer进程同时访问共享对象。因为这种访问将会引起混乱。所谓“读者—写者”问题是指保证一个Writer进程必须与其他进程互斥地访问共享对象地同步问题。
读者-写者问题需要满足3个要求：
(1)读写互斥
(2)写写互斥
(3)允许多个读进程同时访问
这里需要用到3个信号量，wmutex，rmutex，和q 分别用来限制写者和读者的互斥，读者计数的互斥，和保证读写公平
当读者准备读时，会首先占有rmutex来计数，此时有读线程正在读，所以申请了wmutex来让写者阻塞，而后释放掉rmutex信号量，再进行操作，操作后也要登记退出，如果退出后没有读线程了，就释放掉wmutex让写线程可以进入操作。
这里加入了q信号量来保证读写公平。也就是对读者加入了另一个限制，就是q信号量，否则如果读者线程过多，那写者线程会长时间阻塞。

下面展示代码。


import java.util.concurrent.Semaphore;

//实现了3个要求
//(1)读写互斥
//(2)写写互斥
//(3)允许多个读进程同时访问

class Reader implements Runnable {

	private ReaderAndWriter rw;
	private String name;

	public Reader() {}
	public Reader(ReaderAndWriter rw,String name) {
		this.rw = rw;
		this.name = name;
	}

	public void run() {
		while (true) {
			try {
				rw.read(name);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

class Writer implements Runnable {
	
	private ReaderAndWriter rw;
	private String name;
	
	public Writer() {}
	public Writer( ReaderAndWriter rw,String name) {
		this.rw = rw;
		this.name = name;
 
	}
 
	public void run() {
		while (true) {
			try {
				rw.write(name);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}



public class ReaderAndWriter {
	
	private int readcount = 0;
	private Semaphore wmutex = new Semaphore(1);
	private Semaphore rmutex = new Semaphore(1);
	private Semaphore q = new Semaphore(1);
	public void read(String s) {
		try {
			q.acquire();
			rmutex.acquire();
			if (readcount == 0) { 
				wmutex.acquire();
			}
			readcount++;
			rmutex.release();
			q.release();
			System.out.println(s + "----正在读");
			Thread.sleep(1000*2);
			System.out.println(s + "----读完了");
			Thread.sleep(500);
			rmutex.acquire();
			readcount--;
			if (readcount == 0) {
				wmutex.release();
			}
			rmutex.release();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public void write(String s) {
		try {
			q.acquire();
			wmutex.acquire();
			q.release();
			System.out.println(s + "----正在写");
			Thread.sleep(1000*2);
			System.out.println(s + "----写完了");
			Thread.sleep(500);
			wmutex.release();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		ReaderAndWriter rw = new ReaderAndWriter();
	    
        Thread r1 = new Thread(new Reader(rw,"读者1号"));
        Thread r2 = new Thread(new Reader(rw,"读者2号"));
        Thread r3 = new Thread(new Reader(rw,"读者3号"));
        Thread w1 = new Thread(new Writer(rw,"写者1号"));
        Thread w2 = new Thread(new Writer(rw,"写者2号"));
     

        r1.start();
        r2.start();
        r3.start();
        w1.start();
        w2.start();

	}

}

哲学家就餐

有五个哲学家公用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有5个万和五只筷子，他们的生活方式是交替地进行思考和进餐。平时，一个哲学家进行思考，饥饿便试图取用其左右最靠近他的筷子，只有在他拿到两只筷子时才能进餐。进餐完毕时，放下筷子继续思考。
思路是让奇数号的哲学家先拿左手筷子，再拿右手筷子，让偶数号的哲学家先拿右手筷子，再拿左手筷子，这样就可以避免死锁了。
下面展示代码。

import java.util.concurrent.Semaphore;


public class PhilosopherMain {
	private static Semaphore chop[] = new Semaphore[5];
	private static Philosopher p[] = new Philosopher[5];
	
	
	static class Philosopher implements Runnable{
		private int i;
		Philosopher(int i){
			this.i=i;
		}
		@Override
		public void run() {
			while(true) {
				try {
					if(i%2!=0) {
						chop[i].acquire();
						System.out.println("哲学家"+i+"号拿起了了"+ i+"号筷子");
						chop[(i+1)%5].acquire();
						System.out.println("哲学家"+i+"号拿起了了"+ (i+1)%5+"号筷子");
					}else {
						chop[(i+1)%5].acquire();
						System.out.println("哲学家"+i+"号拿起了了"+ (i+1)%5+"号筷子");
						chop[i].acquire();
						System.out.println("哲学家"+i+"号拿起了了"+ i+"号筷子");
					}
					System.out.println("哲学家"+i+"号正在吃饭");
					Thread.sleep(1000*2);
					if(i%2!=0) {
						chop[i].release();
						System.out.println("哲学家"+i+"号放下了"+ i+"号筷子");
						chop[(i+1)%5].release();
						System.out.println("哲学家"+i+"号放下了"+ (i+1)%5+"号筷子");
					}else {
						chop[(i+1)%5].release();
						System.out.println("哲学家"+i+"号放下了"+ (i+1)%5+"号筷子");
						chop[i].release();
						System.out.println("哲学家"+i+"号放下了"+ i+"号筷子");
					}
					System.out.println("哲学家"+i+"号吃完饭了，正在思考");
					Thread.sleep(1000*2);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			
		}

	}
	
	public static void main(String arg[]) {
		
		for(int i=0;i<5;i++) {
			chop[i] = new Semaphore(1);
			p[i] = new Philosopher(i);
		}
		for(int i=0;i<5;i++) {
			new Thread(p[i]).start();
		}
	}
}
wzhwantmoney
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
模拟实现一个多线程环境
simpleman7210的专栏
07-15 2300
引言 初学者或者一些有经验的开发人员，并不总是对于系统底层有清楚的了解。比如，进程（或线程）调度是如何实现的？往往只停留于模糊的认识。了解这些问题的最好途径是亲自实践。然而开发一个真实系统的门槛很高，而通过学习一个已有系统来了解也非易事，因为错综复杂的代码和关系有时把人搞糊涂了。于是学习者往往写一些模拟程序来努力表达系统是怎样运作的。不过，这些程序往往过于简单。于是“看看能否写一个模拟进程调度的
学习笔记：多线程Java Socket编程示例
08-17
其中采用Java 的ExecutorService来进行线程池的方式实现多线程,模拟客户端多用户向同一服务器端发送请求. 注意，此为学习笔记，可以作为参考学习使用，不建议商业使用或生产使用。 废话不多说，直接上代码。
多线程模拟
01-16
生产者搬运者消费者多线程模拟过程，比较形象
模拟多线程
worm_1的博客
12-10 823
用两个线程玩猜数字游戏，第一个线程负责随机给出1~100之间的一个整数，第二个线程负责猜出这个数。要求每当第二个线程给出自己的猜测后，第一个线程都会提示“猜小了”、“猜大了”或“猜对了”。猜数之前，要求第二个线程要等待第一个线程设置好要猜测的数。第一个线程设置好猜测数之后，两个线程还要相互等待，其原则是：第二个线程给出自己的猜测后，等待第一个线程给出的提示；第一个线程给出提示后，等待给第二个线程给
多线程并发模拟实例
zhaoyang10的专栏
10-21 366
SpringBoot+Redis：模拟 10w 人的，秒杀抢单！
多线程模拟练习
创世纪GENESIS
02-01 715
package pxyhomeworkday11; /*第二题：分析以下需求，并用代码实现 有100份礼品,两人（小刚和小明）同时发送，当剩下的礼品小于10份的时候则不再送出，利用多线程模拟该过程并将线程的名称打印出来. 打印格式：小刚送出了礼物，还剩99份礼物。                    小刚送出了礼物，还剩98份礼物。                    小明送出了礼物
java线程学习笔记
07-30
Java 线程学习笔记 Java 线程创建有两种方法： 1. 继承 Thread 类，重写 run 方法：通过继承 Thread 类并重写 run 方法来创建线程，这种方法可以使线程具有自己的执行逻辑。 2. 实现 Runnable 接口：通过实现 ...
婚庆管理系统java源码-LearnThread:学习Java多线程
06-06
婚庆管理系统java源码 Commit图例 序号 emoji 在本项目中的含义 简写标记 (0) :party_popper: 初始化项目:: :tada: ...更新文档，包括但不限于README ...发布新的阅读笔记 ...注意：很多多线程是模拟出来，真正的多线程是
python爬虫学习笔记，通过html标签获取网页内容
03-20
bs4 通过html标签获取网页内容、Xpath解析、模拟登录cookies、多线程，多进程、selenium的使用
Java秒杀系统方案优化高性能高并发学习实战源代码以及笔记..zip
最新发布
03-03
自定义变量模拟多用户(线程组 -> 添加 -> 配置元件 -> CVS数据文件设置) jmeter在命令行下的使用. 下载tgz,解压缩并替换windows视窗下面配置的CVS信息路径 执行脚本 ./bin/jmeter.sh -n -t xxx.jmx -l result.jtl ...
JAVA模拟多线程并发Demo及其解决方案
y_w_x_k的博客
04-17 2457
Account类: package ThreadSafe; public class Account { private String account; private double balance; public Account() { } public Account(String account, double balance) { this.account = account; this.balance = bal
多线程的三种种实现方式以及过程模拟
lx5210521的博客
04-21 326
1、通过创建一个类继承Thread类，然后创建该类的对象，然后调用该对象的start（）方法，start（）方法会调用native方法start0(),该方法由虚拟机直接调用，底层是C/C++实现，然后开启一个线程进入就绪态由CPU调度。2、通过创建一个类实现Runable接口，创建该类的对象，再实现Thread类，将该类的对象作为构造参数传给Thread类对象，再调用Thread类对象的start（）方法。有些类已经继承了其他类，不可以再继承Thread类，只能通过实现Runable接口。
多线程详解
weixin_44383366的博客
11-06 159
目录 多线程 1概述 1.1任务 1.2进程 1.3多线程 2静态代理 3 Lamda 表达式 4 线程 4.1线程的创建方式 4.1.1 继承Thread类（重点） 4.1.2实现Runnable接口（重点） 4.1.3实现callable接口（了解） 4.2 线程状态 4.2.1 停止线程 4.2.2 线程休眠 4.2.3 线程礼让 yield 4.2.4线程强制执行 4.2.5线程状态观测 4.3.6 优先级 4.3.7 线程守护(daemon) 5线程同
实现多线程的两种方式
超级程序诞生的博客
04-30 1031
一、线程详解： 在操作系统中运行的程序就是进程，比如你的qq，播放器，游戏，IDE等等。。。 一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，叫main线程，不然没有存在的意义。线程是CPU调度和执行的单位。 注意：很多线程是模拟出来的，
多线程问题，三个线程轮流进行，每个线程进行n次操作，共执行n*n*3次操作。本代码用三军攻击做演示，通俗易懂。
Elementer的专栏
09-30 2047
package com.yyj.zxy; public class SanJunFight { /** * 三只部队轮流上战场，每只部队在战场上每一轮只能进行10次攻击； * 合计攻击300次则停止攻击； */ private static int count = 1; //攻击计数器 private static int part = 1; //默认第一支部队先进行第一
起三个线程，每个线程执行三次，按顺序轮流执行，输出1-99
qq502948261的博客
09-03 551
package com.cheguo.adminmanage; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * Created with IntelliJ IDEA. * * @author: yangxianyu * Date: 2018/6/10 ...
多线程练习（一） 三个线程按顺序执行
weixin_43234372的博客
05-03 499
多线程练习（一） 三个线程按顺序执行 方法一： 利用join()方法，join()方法可以让父线程等待子线程结束之后才能继续运行。具体join()的解释在 链接: link. import java.util.concurrent.ThreadPoolExecutor; public class ABC{ public static void main(String[] args) { ...
模拟多个线程执行任务，限制只能开启固定大小的线程
雨天的麦子的博客
08-18 229
实现目标 实现现有20个线程去执行各自的任务，但是同一时刻只能开启5个线程去执行任务，只有某一个执行完了才能继续开启下面的线程，相关代码如下所示。 实现思路： 使用中间变量CONTROLLER来控制当前线程的大小。如果创建线程那就向队列加一个值，如果执行完了就拿出来一个值，并唤醒其他线程，这时其他线程发现有一个走了就会争抢新出的这个名额，当一个线程抢到了，其他就会阻塞掉。 public class CaptureService { private static final List<Thr
模拟三个老师同时分发80份学习笔记，每个老师相当于一个线程。
04-23
针对你的问题，我们可以使用多线程来模拟三个老师同时分发80份学习笔记。 首先，我们需要定义一个分发学习笔记的函数，然后将其放在一个线程中执行。这个函数的作用是将80份学习笔记均匀地分配给三个老师。 代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值