java并行计算--Semaphore信号量的简单使用

多线程不仅适用于IO密集型任务，而且在计算型密集型任务也是同样很有优势，最直观的就是快嘛！先来假设一个任务场景：

假设场景：

有一个计算任务：需要先计算出A,B的结果，通过A,B结果得到C结果，通过A,B,C结果得到结果D，试用多线程完成任务！！

分析

我们知道线程的执行顺序具有不可预测性，那么直接使用4个线程去跑，那么由于执行顺序就会无法预测，结果的正确性就得不到保证，如何控制线程的执行顺序就成为最主要的解决问题。这里我们就需要使用Semaphore这个类库了。我们来看jdk文档的介绍：

一个计数信号量。从概念上讲，信号量维护了一个许可集。
如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。
每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。
但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。
Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目

我们通过这种信号量的阻塞方式来实现线程的执行方式，通过 acquire()阻塞， release() 来释放阻塞。来看一段小程序：

package cacl;

import java.util.concurrent.*;

/**
* Created by lewis on 2017/3/28.
*
*
*/
public class Cacl {

private static volatile Semaphore a,b,c,d;

static {
a = new Semaphore(0);
b = new Semaphore(0);
c = new Semaphore(0);
d = new Semaphore(0);
}

public static void main(String []args){
Thread t1 = new Thread(new A());
Thread t2 = new Thread(new B());
Thread t3 = new Thread(new C());
Thread t4 = new Thread(new D());
t1.start();
t2.start();
t3.start();
t4.start();
}
public static <T> void print(T s){
System.out.println(s);
}

static class  A implements Runnable{
@Override
public void run() {
print("A");
a.release();
}
}

static class  B implements Runnable{
@Override
public void run() {
print("B");
b.release();
}
}
static class  C implements Runnable{
@Override
public void run() {
try {
a.acquire();
b.acquire();
print("C");
c.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class  D implements Runnable{
@Override
public void run() {
try {
c.acquire();
print("D");
d.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

这段程序是输出A,B,C,D字符。程序使用了信号量保证了线程的执行顺序，使得输出A,B是并行，所以输出的顺序是随机的，[A,B],C,D这三个是串行，而且具有顺序的输出。

那么我们就可以用来完成并行计算的任务：

以下程序完成了假设的任务场景。现实生活中的应用嘛~可以刷ACM题的试试，说不定TLE的题就过了，但是据我所知有些OJ（codeforces）会检测多线程的使用，检测到就直接报错了。

package cacl;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
* Created by lewis on 2017/3/28.
*
*  并行计算
*
*/
public class Sums {

/**
* A:1+2+3+............+10000
* B:1+sqrt(1)+sqrt(3)+..........sqrt(10000)
* C:10+.............................+10[SUM(10000*10)] + C + D
* D:1*1+2*2+..................100*100 + C
* */
private static volatile Semaphore a,b,c,d;

private static volatile int resA,resB,resC,resD;

static {
a = new Semaphore(0);
b = new Semaphore(0);
c = new Semaphore(0);
d = new Semaphore(0);
}

public static void main(String []args){
ExecutorService executorService = Executors.newFixedThreadPool(4);
ArrayList<Callable<Integer>> list = new ArrayList<>();
list.add(new A());
list.add(new B());
list.add(new C());
list.add(new D());
List<Future<Integer>> futures = null;
try {
futures = executorService.invokeAll(list);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
executorService.shutdown();
}

for(Future<Integer>future:futures){
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
public static <T> void print(T s){
System.out.println(s);
}

static class  A implements Callable<Integer>{

@Override
public Integer call() throws Exception {

synchronized (this){
int res = 0;
for(int i = 0;i<10000;i++){
res += i;
}
resA = res;
a.release();
return resA;
}
}
}

static class  B implements  Callable<Integer>{

@Override
public Integer call() throws Exception {
synchronized (this) {
int res = 0;
for (int i = 0; i < 10000; i++) {
res += Math.sqrt(i);
}
resB = res;
b.release();
return resB;
}
}
}
static class  C implements  Callable<Integer>{

@Override
public Integer call() throws Exception {
synchronized (this){
a.acquire();
b.acquire();
int res = 0;
for(int i = 0;i<100;i++){
res += i*i;
}
resC = res + resA + resB;
c.release();
return resC;
}
}
}
static class  D implements  Callable<Integer>{

@Override
public Integer call() throws Exception {
synchronized(this){
c.acquire();
int res = 0;
for(int i = 0;i<10000;i++){
res += 10;
}
resD = res + resC + resA +resB;
d.release();
return resD;
}
}
}
}