java并发编程学习:用 Semaphore (信号量)控制并发资源

并发编程这方面以前关注得比较少,恶补一下,推荐一个好的网站:并发编程网 - ifeve.com,上面全是各种大牛原创或编译的并发编程文章。

今天先来学习Semaphore(信号量),字面上看,根本不知道这东西是干啥的,借用 并发工具类(三)控制并发线程数的Semaphore一文中的交通红绿信号灯的例子来理解一下:

一条4车道的主干道,假设100米长,每辆车假设占用的长度为10米(考虑到前后车距),也就是说这条道上满负载运行的话,最多只能容纳4*(100/10)=40辆车,如果有120辆车要通过的话(为简单起见,一波40辆,分成3波),就必须要红绿信号灯来调度了,对于最前面的一波来讲,它们看到的是绿灯,允许通过,第一波全进入道路后,红绿灯变成红色,表示后面的2波,要停下来等候第1波车辆全通过,然后红绿灯才会变成绿色,让第2波通过,如此运转下去....

这跟多线程并发有啥关系呢?Semaphore就是红绿信号灯,3波车辆就是3个并发的线程,而主干道就是多个线程要并发访问的公用资源,由于资源有限,所以必须通过Semaphore来控制线程对资源的访问,否则就变成资源竞争,严重的话会导致死锁等问题。

下面用一个示例演示,假设有N个并发线程都要打印文件,但是打印机只有1台,先来一个打印队列类:

package yjmyzz.lesson01;

import java.util.concurrent.Semaphore;

public class PrintQueue {

    private final Semaphore semaphore;

    public PrintQueue() {
        semaphore = new Semaphore(1);//限定了共享资源只能有1个(相当于只有一把钥匙)
    }

    public void printJob(Object document) {
        try {
            semaphore.acquire();//取得对共享资源的访问权(即拿到了钥匙))

            long duration = (long) (Math.random() * 10);
            System.out.printf("%s: PrintQueue: Printing a Job during %d seconds\n", Thread.currentThread().getName(), duration);
            Thread.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();//钥匙用完了,要还回去,这样其它线程才能继续有序的拿到钥匙,访问资源
        }
    }
}

由于是在多线程环境中,真正运行的作业处理,得继承自Runnable(或Callable)

package yjmyzz.lesson01;

public class Job implements Runnable {

    private PrintQueue printQueue;

    public Job(PrintQueue printQueue) {
        this.printQueue = printQueue;
    }

    public void run() {
        System.out.printf("%s: Going to print a job\n", Thread.currentThread().getName());
        printQueue.printJob(new Object());
        System.out.printf("%s: The document has been printed\n", Thread.currentThread().getName());
    }
}

好了,测试一把:

package yjmyzz.lesson01;

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

        PrintQueue printQueue = new PrintQueue();

        int threadCount = 3;

        Thread thread[] = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {
            thread[i] = new Thread(new Job(printQueue), "Thread" + i);
        }

        for (int i = 0; i < threadCount; i++) {
            thread[i].start();
        }
    }
}

输出:

Thread0: Going to print a job
Thread2: Going to print a job
Thread1: Going to print a job
Thread0: PrintQueue: Printing a Job during 7 seconds
Thread0: The document has been printed
Thread2: PrintQueue: Printing a Job during 5 seconds
Thread2: The document has been printed
Thread1: PrintQueue: Printing a Job during 0 seconds
Thread1: The document has been printed

从输出上看,线程0打印完成后,线程2才开始打印,然后才是线程1,没有出现一哄而上,抢占打印机的情况。这样可能没啥感觉,我们把PrintQueue如果去掉Semaphore的部分,变成下面这样:

package yjmyzz.lesson01;

public class PrintQueue {

    //private final Semaphore semaphore;

    public PrintQueue() {
        //semaphore = new Semaphore(1);//限定了共享资源只能有1个(相当于只有一把钥匙)
    }

    public void printJob(Object document) {
        try {
            //semaphore.acquire();//取得对共享资源的访问权(即拿到了钥匙))
            long duration = (long) (Math.random() * 10);
            System.out.printf("%s: PrintQueue: Printing a Job during %d seconds\n", Thread.currentThread().getName(), duration);
            Thread.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //semaphore.release();//钥匙用完了,要还回去,这样其它线程才能继续有序的拿到钥匙,访问资源
        }
    }
}

这回的输出:

Thread0: Going to print a job
Thread2: Going to print a job
Thread1: Going to print a job
Thread2: PrintQueue: Printing a Job during 4 seconds
Thread1: PrintQueue: Printing a Job during 8 seconds
Thread0: PrintQueue: Printing a Job during 0 seconds
Thread0: The document has been printed
Thread2: The document has been printed
Thread1: The document has been printed

可以发现,3个线程全都一拥而上,同时开始打印,也不管打印机是否空闲,实际应用中,这样必然出问题。

好的,继续,突然有一天,公司有钱了,又买了2台打印机,这样就有3台打印机了,这时候怎么办呢?简单的把PrintQueue构造器中的

    public PrintQueue() {
        semaphore = new Semaphore(3);
    }

就行了吗?仔细想想,就会发现问题,代码中并没有哪里能告诉线程哪个打印机正在打印,哪个打印机当前空闲,所以仍然有可能出现N个线程(N<=3)同时抢一台打印机的情况(即:如果把控制权当成钥匙的话,相当于有可能3个人各领取到了1把钥匙,但是这3把钥匙是相同的,3个人都看中了同一个箱子,都要用手中的钥匙去抢着开箱)。

所以得改进一下:

package yjmyzz.lesson02;

import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PrintQueue {

    private boolean freePrinters[];//用来存放打印机的状态,true表示空闲,false表示正在打印

    private Lock lockPrinters;//增加了锁,保证多个线程,只能获取得锁,才能查询哪台打印机空闲的

    private final Semaphore semaphore;

    public PrintQueue() {
        int printerNum = 3;//假设有3台打印机
        semaphore = new Semaphore(printerNum);
        freePrinters = new boolean[printerNum];

        for (int i = 0; i < printerNum; i++) {
            freePrinters[i] = true;//初始化时,默认所有打印机都空闲
        }
        lockPrinters = new ReentrantLock();
    }

    private int getPrinter() {
        int ret = -1;
        try {
            lockPrinters.lock();//先加锁,保证1次只能有1个线程来获取空闲的打印机
            for (int i = 0; i < freePrinters.length; i++) {
                //遍历所有打印机的状态,发现有第1个空闲的打印机后,领取号码,
                // 并设置该打印机为繁忙状态(因为马上就要用它)
                if (freePrinters[i]) {
                    ret = i;
                    freePrinters[i] = false;
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //最后别忘记了解锁,这样后面的线程才能上来领号
            lockPrinters.unlock();
        }
        return ret;
    }

    public void printJob(Object document) {
        try {
            semaphore.acquire();

            int assignedPrinter = getPrinter();//领号
            long duration = (long) (Math.random() * 10);
            System.out.printf("%s: PrintQueue: Printing a Job in Printer%d during %d seconds\n", Thread.currentThread().getName(),
                    assignedPrinter, duration);
            Thread.sleep(duration);
            freePrinters[assignedPrinter] = true;//打印完以后,将该打印机重新恢复为空闲状态

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

测试一下,这回把线程数增加到5,输出结果类似下面这样:

Thread0: Going to print a job
Thread4: Going to print a job
Thread3: Going to print a job
Thread2: Going to print a job
Thread1: Going to print a job
Thread4: PrintQueue: Printing a Job in Printer1 during 7 seconds
Thread0: PrintQueue: Printing a Job in Printer0 during 4 seconds
Thread3: PrintQueue: Printing a Job in Printer2 during 8 seconds
Thread0: The document has been printed
Thread2: PrintQueue: Printing a Job in Printer0 during 0 seconds
Thread2: The document has been printed
Thread4: The document has been printed
Thread1: PrintQueue: Printing a Job in Printer0 during 0 seconds
Thread3: The document has been printed
Thread1: The document has been printed

从输出结果可以看出,一次最多只能有3个线程使用这3台打印机,而且每个线程使用的打印机互不冲突,打印完成后,空闲的打印机会给其它线程继续使用。

参考文章:

http://ifeve.com/thread-synchronization-utilities-2/

http://ifeve.com/thread-synchronization-utilities-3/

http://ifeve.com/concurrency-semaphore/

时间: 2024-11-03 21:44:59

java并发编程学习:用 Semaphore (信号量)控制并发资源的相关文章

并发编程中:Semaphore信号量与lock的区别

Semaphore,信号量,常用于限制可以访问某些资源的线程数量,比如连接池.对象池.线程池等等.其中,你可能最熟悉数据库连接池,在同一时刻,一定是允许多个线程同时使用连接池的,当然,每个连接在被释放前,是不允许其他线程使用的. 信号量实现了一个最简单的互斥锁功能.估计你会觉得奇怪,既然有 Java SDK 里面提供了 Lock,为啥还要提供一个 Semaphore ?其实实现一个互斥锁,仅仅是 Semaphore 的部分功能,Semaphore 还有一个功能是 Lock 不容易实现的,那就是:

Java并发编程学习笔记

Java编程思想,并发编程学习笔记. 一.基本的线程机制 1.定义任务:Runnable接口 线程可以驱动任务,因此需要一种描述任务的方式,这可以由Runnable接口来提供.要想定义任务,只需实现Runnable接口并编写run方法,使得该任务可以执行你的命令.   class MyTask implements Runnable {    private String mName;     public MyTask(String name) {    mName = name;   }  

Java并发编程学习笔记(一)线程安全性 1

什么是线程安全性: 要编写线程安全的代码,其核心在于要对状态访问操作进行管理,特别是对共享的和可变的状态的访问."共享"意味着变量可以由多个线程同时访问,而"可变"则意味着变量的值在其生命周期内可以发生变化. 一个对象是否需要线程安全的,取决于他是否被多个线程访问.这指的是在程序中访问对象的方式,而不是对象要实现的功能.要使得对象时线程安全的,需要采用同步机制来协同对对象可变状态的访问.如果无法实现协同,那么可能导致数据破坏以及其他不该出现的结果. 如果当多个线程访

黑马程序员-Java面向对象编程学习总结

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- Java面向对象编程学习总结: 重要知识点总结如下: 1,抽象,封装,继承,多态是面向对象程序设计中得四个特点. 2,面向对象得软件开发大体分为:面向对象的分析,面向对象的设计,面向对象的实现. 可概括为如下过程:分析用户需求,从问题中抽

JAVA GUI编程学习笔记目录

1.JAVA之GUI编程概述 2.JAVA之GUI编程布局 3.JAVA之GUI编程Frame窗口 4.JAVA之GUI编程事件监听机制 5.JAVA之GUI编程窗体事件 6.JAVA之GUI编程Action事件 7.JAVA之GUI编程鼠标事件 8.JAVA之GUI编程键盘码查询器 9.JAVA之GUI编程列出指定目录内容 10.JAVA之GUI编程弹出对话框Dialog 11.JAVA之GUI编程菜单 12.JAVA之GUI编程打开与保存文件 13.JAVA之GUI编程将程序打包jar JA

Java语言编程学习之Lambda表达式设计和架构的原则[图]

Java语言编程学习之Lambda表达式设计和架构的原则[图]:大家都知道,Lambda表达式是对Java语言的一点简单改进,在JDK标准类库中,运行它的方式各种各样.但是大多数的Java代码都不是由开发JDK的程序猿写的,而是像我们这样的普通程序猿.很多人都会碰到过这样的情况:你实现了一个新功能或修复了一个缺陷,并且对自己的修改很满意.但其他人看了你的代码后--也许发生在代码审查环节,完全不买账!对于什么是好代码,什么是坏代码,存在分歧很正常!设计模式的改变设计模式是人们熟悉的另一种设计思想,

学习笔记:java并发编程学习之初识Concurrent

一.初识Concurrent 第一次看见concurrent的使用是在同事写的一个抽取系统代码里,当时这部分代码没有完成,有许多的问题,另一个同事接手了这部分代码的功能开发,由于他没有多线程开发的经验,所以我就一起帮着分析.最开始看到这个时很烦燥啊,因为自己接触java时间很短,连synchronized都不知道怎么用呢,突然发现有这么个复杂的东西.当时就只好开始学习吧,毕竟是使用嘛,第一目的就是了解清楚这玩意的各个类与方法都干嘛用的,然后看了看同事的代码大概也就清楚了.感觉这和大部分人一样,能

Java并发工具类(三)控制并发线程数的Semaphore

作用 Semaphore(信号量)是用来控制同时访问特定资源的线程数量,它通过协调各个线程,以保证合理的使用公共资源. 简介 Semaphore也是一个线程同步的辅助类,可以维护当前访问自身的线程个数,并提供了同步机制.使用Semaphore可以控制同时访问资源的线程个数,例如,实现一个文件允许的并发访问数. 主要方法摘要: void acquire():从此信号量获取一个许可,在提供一个许可前翼子将线程阻塞,否则线程被中断. void release():释放一个许可,将其返回给信号量. in

java并发编程-学习

disruptor:https://www.cnblogs.com/sigm/p/6251910.html 自旋锁等:http://www.cnblogs.com/lzh-blogs/p/7477157.html 1.竞态条件:多个线程共享相同的内存地址空间,并且并发执行下发生访问或修改其他线程正在使用的变量,而导致结果不一致. 2.活跃性:某件正确的事情最终发生,但不够好,因此需要解决性能问题 3.在多线程中,当线程调度器临时挂起活跃线程并转而运行另外一个线程时,就会产生频繁的上下文切换(Co