12/04 学习记录

今天偶然翻开上学期的操作系统笔记，看到线程同步那块，记着当时首先讲的是锁，之后讲了semaphore。

 

-先复习下基本概念

   一个二元信号量和一个锁有相同的功能

   一个初始成0的信号量，就可用来阻塞一个线程

   信号量和锁不同的地方在于，对于锁来说，进行lock和unlock的线程是同一个，而对于信号量来讲，P和V操作并不一定是同一个线程执行的。

 

-为了复习，就实现了一个很简单的Semaphore类，用到了锁。有什么不正确的地方，还请大家指正。

package semaphore;

public class Semaphore {

    private int count;
    private Object mutex;//这个锁是必须要用的，因为这里有个count变量会被很多线程共享使用


    //这两个string是做测试用的

    private final String message_1 = " I get a place !!";
    private final String message_2 = " I 've leaved !!";

    public Semaphore(int n) {

        this.count = n;
        this.mutex = new Object();

    }

    public void P_operation(String name) throws InterruptedException {

        synchronized (mutex) {

            while (count == 0) {
                System.out.println(name + " is waiting");
                mutex.wait();
            }

            count--;
            System.out.println(name+message_1);

        }

    }

    public void V_operation(String name) {

        synchronized (mutex) {
            count++;
            System.out.println(name+message_2);
            mutex.notify();
        }

    }

}

-下面假设如下场景，用刚刚实现的semaphre来模拟一下

一个停车场，有3个车位，现在有10个顾客要来停车。当还有空位时，顾客可以进入，否则就一直等到有空位为止。假设每个顾客要停车的时间是随机的。

 

先定义Park线程类

 

package semaphore;

public class Park extends Thread {

    private Semaphore sph;
    private String name;

    public Park(Semaphore s, String name) {

        super(name);
        this.name = name;
        this.sph = s;

    }

    public void parking() {

        try {
            Thread.sleep((long) (Math.random() * 1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public void run() {

        //先尝试获得一个空位
        try {
            sph.P_operation(name);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        //得到停车位，停车ing....
        parking();

        //要离开了，把车位还回
        sph.V_operation(name);
    }

}

 

-main

 

package semaphore;

public class Main {
    public static void main(String[] args) {

        Semaphore sph = new Semaphore(3);

        Thread []park = new Thread[10];

        for(int i = 0;i<10;i++){
            park[i] = new Park(sph,"client-"+i);
            park[i].start();
        }

    }
}

打印结果如下

 

client-0 I get a place !!
client-4 I get a place !!
client-1 I get a place !!
client-2 is waiting
client-3 is waiting
client-6 is waiting
client-8 is waiting
client-5 is waiting
client-7 is waiting
client-9 is waiting
client-4 I 've leaved !!
client-2 I get a place !!
client-0 I 've leaved !!
client-3 I get a place !!
client-3 I 've leaved !!
client-6 I get a place !!
client-2 I 've leaved !!
client-8 I get a place !!
client-1 I 've leaved !!
client-5 I get a place !!
client-5 I 've leaved !!
client-7 I get a place !!
client-8 I 've leaved !!
client-9 I get a place !!
client-6 I 've leaved !!
client-9 I 've leaved !!
client-7 I 've leaved !!

顺便想说的是，jdk引入条件变量后，在程序中就可以更精确的控制同步。

比如上面的例子改一下，顾客中存在优先级别，比如有vip和普通顾客，那么，要就vip优先得到车位。即对于普通顾客来说，得到车位的条件是 -有车位&vip已经得到车位-。

此时，我们需要有两个等待队列，这里不算object的锁队列。

对于一个普通顾客来说，可能他首先被加入到等待空闲车位的队列，当某时刻被唤醒后，可能又进入了等待vip的队列。

类似这种有优先级的问题，如果只使用信号量来实现，会很麻烦，有了条件变量，就方便多了，可以自定义需要的等待队列。

---------------------------------------------------

周一就开学了，这一周假期好快啊