原创转载请注明出处：http://agilestyle.iteye.com/blog/2342878
Semaphore所提供的功能完全是synchronized关键字的升级版，但它提供的功能更加的强大和方便，主要的作用是控制线程并发的数量。
Semaphore(int permits)
设置permits为1
Service.java
package org.fool.java.concurrent.semaphore;
import java.util.concurrent.Semaphore;
public class Service {
private Semaphore semaphore = new Semaphore(1);
public void testMethod() {
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName() + " begin timer=" + System.currentTimeMillis());
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName() + " end timer=" + System.currentTimeMillis());
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Note:
permits代表同一时间内，最多允许多少个线程同时执行acquire()和release()之间的代码。
本例设置为1，所以最多只有1个线程同时执行acquire()和release()之间的代码。
ThreadA.java
package org.fool.java.concurrent.semaphore;
public class ThreadA implements Runnable {
private Service service;
public ThreadA(Service service) {
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}
ThreadB.java
package org.fool.java.concurrent.semaphore;
public class ThreadB implements Runnable {
private Service service;
public ThreadB(Service service) {
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}
ThreadC.java
package org.fool.java.concurrent.semaphore;
public class ThreadC implements Runnable {
private Service service;
public ThreadC(Service service) {
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}
SemaphoreTest.java
package org.fool.java.concurrent.semaphore;
public class SemaphoreTest {
public static void main(String[] args) {
Service service = new Service();
Thread a = new Thread(new ThreadA(service));
Thread b = new Thread(new ThreadA(service));
Thread c = new Thread(new ThreadA(service));
a.setName("A");
b.setName("B");
c.setName("C");
a.start();
b.start();
c.start();
}
}
Run
Note:
private Semaphore semaphore = new Semaphore(1);
由于定义了最多1个线程执行acquire()和release()之间的代码，所以打印的结果就是3个线程是同步的，线程A执行结束的时间和线程B执行开始的时间相同，线程B执行结束的时间和线程C还行开始的时间相同。
修改Service.java，设置permits为2
private Semaphore semaphore = new Semaphore(2);
再次Run SemaphoreTest
Note:
由于定义了最多2个线程执行acquire()和release()之间的代码，所以线程A和线程B执行开始的时间是相同的，需要注意的是，对Semaphore的构造方法传递的参数permits值如果大于1时，该类并不能保证线程的安全性，因为还是有可能会出现多个线程共同访问实例变量，导致出现脏读。
Semaphore(int permits, boolean fair)
有些时候，获得permits的顺序与线程启动的顺序有关，这时信号量就要分为公平和非公平的。
公平信号量是获得锁的顺序与线程启动的顺序有关，但不代表100%地获得信号量，仅仅是在概率上能得到保证。
非公平信号量即获得锁的顺序与线程启动的顺序无关。
Service.java
package org.fool.java.concurrent.semaphore.fair;
import java.util.concurrent.Semaphore;
public class Service {
private boolean isFair = false;
private Semaphore semaphore = new Semaphore(1, isFair);
public void testMethod() {
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
}
}
Note:
设置了非公平信号量
private boolean isFair = false;
ThreadA.java
package org.fool.java.concurrent.semaphore.fair;
public class ThreadA implements Runnable {
private Service service;
public ThreadA(Service service) {
this.service = service;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " invoked...");
service.testMethod();
}
}
FairTest.java
package org.fool.java.concurrent.semaphore.fair;
public class FairTest {
public static void main(String[] args) {
Service service = new Service();
Thread a = new Thread(new ThreadA(service));
a.start();
for(int i = 0; i < 4; i++) {
new Thread(new ThreadA(service)).start();
}
}
}
Run
非公平信号量运行的效果是线程启动的顺序与调用semaphore.acquire()的顺序无关，也就是线程先启动了并不代表获得permits
修改Service.java，设置公平信号量
private boolean isFair = true;
再Run
公平信号量运行的效果是线程启动的顺序与调用semaphore.acquire()的顺序有关，也就是先启动的线程优先获得permits