OS 学习笔记什么是同步互斥?

Posted adventure.Li

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了OS 学习笔记什么是同步互斥?相关的知识,希望对你有一定的参考价值。

一、背景

最近正在复习OS,为了更好理解其原理,便通过写博客来加深理解。由于知识水平有限,可能存在一些疏漏和不恰当之处,希望大佬们批评指点。

二、同步机制

  1. 什么是同步和互斥?

同步Synchronization也称作制约关系,它是指为完成某种任务而建立的两个或多个进程,这些进程因为要在某些位置上协调它们的工作次序而等待、传递信息所产生的制约关系。进程间的直接制约关系就是源于它们之间的相互合作关系
同步适用对象:(两个或多个)数据库、文件、模块、线程之间用来保持数据内容一致性的机制。

互斥是指某一资源(临界资源,例如打印机、共享公共变量等)同时只允许一个访问者对其进行访问,具有唯一性和排它性

在大多数情况下,同步已经实现了互斥,特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源

异步:相对于同步来说,不进行顺序执行。常JS引擎之使用(单线程)。另外,回调函数是异步操作最基本的方法。
关于异步的介绍

  1. 同步的基本原则
    在看基本原则之前,首先明白,为什么需要同步和互斥?因为 为了提高CPU的利用率,便出现了多批道计算机,这样便可以进行并发(同一间隔,区别并行)操作。而并发操作则带来了如何去分配CPU已经其他资源(如内存,IO,设备等)。而就在处于CPU有限,请求资源过多就需要合理的调度,而为了防止数据不一致则带来了同步和互斥的问题。
  • 空闲让进 当CPU空闲了,就需要让进程进去使用CPU(让CPU忙起来=> 提供CPU利用率)
  • 忙则等待 当CPU有其他进程正在访问时,则需要进行等待,做到互斥,防止数据不一致。
  • 有限等待 当然了,也不能一直等待,这样便会出现饥饿死等现象,用户请求得不到响应。
  • 让权等待 把CPU让给更加需要的请求进程去使用。
  1. 用代码来理解一下同步与互斥

进程1

public class SyncTask1 implements Runnable{
    @Override
    public void run() {
        System.out.println(new Date()+"SyncTask1正在工作...");
        System.out.println(new Date()+"SyncTask1工作结束...");
        // V操作,表面通知另外一个进程可以进行操作了,保证了同步。顺序执行
        SyncDemo.flag = true;
    }
}

进程2

public class SyncTask2 implements Runnable{
    @Override
    public void run() {
        // SyncTask2,它执行的前置动作还未完成,就一直等待,P操作进行检测上个动作是否完成
        while(!SyncDemo.flag);
        System.out.println(new Date()+"SyncTask2开始工作...");
        System.out.println(new Date()+"SyncTask2结束工作...");
    }
}

以上创建了两个进程,为了保证数据的安全和一致性,我们需要让进程2在进程1之后访问,按照顺序执行,也就是进程1是前置条件,进程2必须在进程1完成之后接着进行,这样来保证同步性。接下来进行测试。(其实有点像观察者模式?)

public class SyncDemo {
    // 同步PV操作的判断检测flag
    //volatile
    static public boolean flag = false;
    public static void main(String[]args){
        // 为演示效果,还故意将SyncTask2放在前面进行启动
        new Thread(new SyncTask2()).start();
        new Thread(new SyncTask1()).start();
    }
}

互斥(强调的是不能同时访问临界资源)。那么就设置一个mutex锁来判断是否有进程正在访问临界资源。于是有了以下代码。

public class Thread1 implements Runnable{

    @Override
    public void run() {
        // 当其他进程正在访问时,等待 =>
        while (MutexDemo.resourceMutex==false);
        // P操作,进行访问临界资源前的加锁
        MutexDemo.resourceMutex = false;
        for(int i =0;i<10;i++){
            System.out.println("Thread1 第"+i+"次工作");
            Resources.dataPool.add("产品"+i);
            //Resources.IoResources.;
        }
        // 释放锁,V操作
        MutexDemo.resourceMutex = true;

        // V操作进行提醒其他进程操作,达到同步
    }
}


public class Thread2 implements Runnable{
    @Override
    public void run() {
        while (!MutexDemo.resourceMutex);
        MutexDemo.resourceMutex = false;
        for(int i =0;i<10;i++){
            System.out.println("Thread2 第"+i+"次工作");
            Resources.dataPool.remove("产品"+i);
            //Resources.IoResources.;
        }
        // 释放锁,V操作
        MutexDemo.resourceMutex = true;
    }
}

  1. 生产者消费者问题

分析问题:明确进程数量,以及进程之间的同步和互斥情况。当数据缓存区有空的时候,生产者就进行生产产品,直到无空缓冲区停止生产,当数据缓冲区有满的时候,消费者就进行消费直到无可消费。另外,缓冲区不能同时访问,因此需要加锁。

确定关系:
在这里插入图片描述
有分析问题可知,我们需要empty,full变量来分别表示空缓冲区量和满缓冲区量。以及一个信号量锁mutex来判断是否有进程正在访问临界资源。

整理问题写成代码:

public class Consumer implements Runnable{
    @Override
    public void run() {
        while(true){
            while(Main.full<=0||Main.mutex);

            Main.mutex = true;
            System.out.println(new Date()+"准备消费产品;空buffer区数量为"+Main.empty+";满buffer区数量为" +
                    ""+Main.full);
            Main.full--;
            Main.empty++;
            try {
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println(new Date()+"消费产品结束;空buffer区数量为"+Main.empty+";满buffer区数量为" +
                    ""+Main.full);
            Main.mutex = false;

            try {
                Thread.sleep(2000+new Random().nextInt(2)*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

public class Producer implements Runnable{
    @Override
    public void run() {
        while(true){
            // 同步P操作
            while (Main.empty<=0||Main.mutex);// 当空的buffer区小于等于0时进行等待(忙则等待?),负数代表有进程正在等待(消费者消费过度)?
            // 互斥P操作,加锁
            Main.mutex=true;
            System.out.println(new Date()+"准备生产产品;空buffer区数量为"+Main.empty+";满buffer区数量为" +
                    ""+Main.full);
            Main.full++;// full加一,进行生产产品,导致buffer区满(一次性就生产满》)
            Main.empty--;
            try {
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println(new Date()+"生产产品结束;空buffer区数量为"+Main.empty+";满buffer区数量为" +
                    ""+Main.full);
            // 释放锁(V操作)
            Main.mutex=false;
            //
            try {
                Thread.sleep(20+new Random().nextInt(2)*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

public class Main {
    // 信号量
    static private final int N = 10;
    // 互斥锁,false代表无进程访问临界区
    volatile static public boolean mutex=false;
    // 空的buffer区
    volatile static public int empty=N;
    // 满的buffer区
    volatile static public int full=0;

    public static void main(String[]args){
        new Thread(new Producer()).start();
        new Thread(new Consumer()).start();
    }
}

补充说明:在未加volatile时,会出现和预期不一样的结果,因为设计到Java内存模型机制了。如果不设置volatile那么就不可见,于是在生产者改变mutex时,消费者是不可见的依然保持原有的false因此只会出现生产者的打印。

以上是关于OS 学习笔记什么是同步互斥?的主要内容,如果未能解决你的问题,请参考以下文章

μC/OS-III---I笔记5---多值信号量

C#学习笔记---线程同步:互斥量信号量读写锁条件变量

互斥与同步

10、同步互斥机制3(进程通信)(操作系统笔记)

Linux学习笔记(15)-信号量

读写锁 与 互斥锁