操作系统概念管程Java代码实现

最新推荐文章于 2024-08-16 11:27:36 发布

SuPhoebe

最新推荐文章于 2024-08-16 11:27:36 发布

阅读量3.7k

点赞数 1

分类专栏：计算机学科学习笔记计算机科学与技术专业知识笔记 Java & Scala 文章标签：操作系统 java 管程信号量

本文链接：https://blog.csdn.net/u013007900/article/details/50099261

版权

本文介绍了如何在Java中利用管程实现同步互斥，包括生产者消费者问题、读写问题、哲学家问题、父子苹果橘子问题以及老和尚小和尚挑水问题的解决方案。通过对比信号量与管程的使用，阐述了管程在简化同步操作上的优势。

摘要由CSDN通过智能技术生成

java中利用管程实现同步互斥量

其实我关于代码中信号量和管程的具体差别不是特别的清楚。
但是因为用到了Semaphore类（信号量），就是用信号量实现的。程序员们需要自己对信号量的初始化、更新（wait/signal）以及信号量更新逻辑负责。
而管程应该是用到了synchronized的定义方法，如public synchronized void insert(int val)，这个时候并不需要自己去实现信号量的等待、释放，只需要直接调用就行，

生产者消费者

import java.util.*;

public class ProduceConsume
{
   
    static final int N = 2;//define the size of the buffer
    static producer p = new producer();//initial a thread of producer
    static consumer c = new consumer();//initial a thread of consumer
    static our_monitor mon = new our_monitor();//initial a thread of a new pipe


    public static void main(String args[])
    {
        p.start();
        c.start();
    }


    static class producer extends Thread
    {
   
        public void run()
        {
            int item;
            while(true) //the loop of a producer
            {
                item = produce_item();
                mon.insert(item);
            }
        }
        private int produce_item()
        {
            int p=1;
            System.out.println("Produce:"+p);
            return p;
        }
    }
    static class consumer extends Thread
    {
   
        public void run()
        {
            int item;
            while(true)
            {
                item = mon.remove();
                consume_item(item);
            }
        }
        private void consume_item(int item)
        {
            System.out.println("consumer:"+item);
        }
    }


    static class our_monitor //a pipe
    {
   
        private int buffer[] = new int[N];
        private int count = 0,lo = 0, hi = 0;

        public synchronized void insert(int val)
        {
            try
            {
                Thread.sleep(500);
            }
            catch(InterruptedException e)
            {
                System.out.println("error");
            }
            if(count == N)go_to_sleep();
            buffer[hi] = val;
            hi=(hi + 1) % N;
            count = count + 1;
            if(count == 1)notify();
        }


        public synchronized int remove()
        {
            try
            {
                Thread.sleep(500);
            }
            catch(InterruptedException e)
            {
                System.out.println("error");
            }
            int val;
            if(count == 0)go_to_sleep();
            val = buffer[lo];
            lo = (lo + 1) % N;
            count = count -1;
            if(count == N-1)notify();
            return val;
        }
        private void go_to_sleep()
        {
            try
            {
                wait();
            }
            catch(InterruptedException e)
            {
                System.out.println("error");
            }
        }
    }
}

读写问题

这是用信号量实现的。

import java.util.*;
import java.util.concurrent.Semaphore;

public class OS_Readerwriter
{
   
    static Semaphore sem=new Semaphore(1);
    static Semaphore sem_wrt=new Semaphore(1);
    static int readercount=0;
    static String a="hahaha";
    public static void main(String args[])
    {
        class reader implements Runnable
        {
   
            public reader()
            {

            }
            @Override
            public void run()
            {
                // TODO Auto-generated method stub
                try
                {
                    sem.acquire();
                    readercount++;
                }
                catch (InterruptedException e)
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                if(readercount==1)
                {
                    try
                    {
                        sem_wrt.acquire();
                    }
                    catch (InterruptedException e)
                    {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                sem.release();

                System.out.println("Reading "+a);

                try
                {
                    sem.acquire();
                }
                catch (InterruptedException e)
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                readercount--;
                if(readercount==0)
                {
                    sem_wrt.release();
                }
                sem.release();
            }
        }

        class writer implements Runnable
        {
   
            public writer()
            {

            }
            @Override
            public void run()
            {
                // TODO Auto-generated method stub
                try
                {
                    sem_wrt.acquire();
                }
                catch (InterruptedException e)
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                a=a+"abc";
                System.out.println("Writing "+a);
                sem_wrt.release();
            }
        }
        for(int i=1; i<=10; i++)
        {
            new Thread(new writer()).start();
            new Thread(new reader(