恶补多线程编程实践1之信号量Semaphore

Semaphore 通常我们叫它信号量， 可以用来控制同时访问特定资源的线程数量，通过协调各个线程，以保证合理的使用资源。其实就是一个计数器。

具体的原理其实也很简单，首先初始化一个信号量，并赋给它一个初始化的值，代表他初始化的时候有多少个令牌，然后每次线程在进行操作的时候，可以先进行令牌的获取，如果获取到就可以顺利执行，否则如果信号量中没有令牌了，就会进行阻塞线程。同时还有一个比较关键的操作是释放令牌，其实也就是往信号量里添加令牌。

核心的API：

Semaphore sm = new Semaphore(n); //初始化令牌数n
sm.acquire();// 就是获取令牌 令牌会减一
sm.release();// 释放令牌，那么此时话唤醒一个之前没有拿到令牌而阻塞的线程
sm.availablePermits()//返回可用的令牌数量。

应用一：停车场场景，车位数量有限，同时只能容纳10台车，车位满了之后只有等里面的车离开停车场外面的车才可以进入。

public class Semaphore_application {
    /*停车场场景，车位数量有限，同时只能容纳多少台车，
    车位满了之后只有等里面的车离开停车场外面的车才可以进入。
    * */
    static Semaphore sm = new Semaphore(5);
    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            Thread th = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "来停车了");

                    if (sm.availablePermits() == 0) {//没令牌了 你等着吧
                        System.out.println("车位不足，请耐心等待");
                    }
                    try {
                        sm.acquire();//获取牌子
                        System.out.println(Thread.currentThread().getName() + "停车成功");
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName() + "驶出停车场");
                        sm.release();//释放牌子
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }, i + "号车");
            th.start();
        }
    }
}

应用二：关于令牌的数量的理解。release()就是释放令牌，其实就是添加一个令牌，而acquire()是获取令牌，会减少一个令牌。

class Semaphore_application1 {
    public static void main(String[] args) {
        Semaphore sm = new Semaphore(0);
        System.out.println(sm.availablePermits());//当前令牌的数量
        sm.release();//释放令牌 令牌数+1

        System.out.println(sm.availablePermits());
        for (int i = 0; i < 5; i++) {
            Thread th = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        sm.acquire();
                        System.out.println(Thread.currentThread().getName() + "run");
                        sm.release();
                        System.out.println("令牌+1" + ":" + sm.availablePermits());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            th.start();
        }
    }
}

应用三：交替打印 FooBar

两个不同的线程将会共用一个 FooBar 实例：

线程 A 将会调用 foo() 方法，而线程 B 将会调用 bar() 方法,请设计修改程序，以确保 “foobar” 被输出 n 次。

//使用两个线程 然后顺序打印foobar一共n次
class Semaphore_application2 {
    public static void main(String[] args) {
        FooBar fb = new FooBar(5);
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                fb.foo();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                fb.bar();
            }
        });

        t1.start();;
        t2.start();
    }


}

//使用信号量的方式 再打印foo时让bar阻塞 在打印bar时让foo阻塞即可
class FooBar {
    private int n;
    private Semaphore fooSema = new Semaphore(1);
    private Semaphore barSema = new Semaphore(0);

    public FooBar(int n) {
        this.n = n;
    }

    public void foo(){
        for (int i=0;i<n;i++) {
            try {
                fooSema.acquire();//只有获取到fooSema的信号量的令牌才能打印
                System.out.print("foo");
                barSema.release();//给barSema信号量添加令牌
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void bar(){
        for (int i=0;i<n;i++){
            try {
                barSema.acquire();
                System.out.print("bar");
                fooSema.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}