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

本文介绍了如何在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(
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值