使用Lock，wait/notify，Semaphore三种方式实现多线程通信

java的多线程通信有Lock，wait/notify，Semaphore三种方式，以一道常见面试题来简单演示这三种多线程通信方式。

两个线程循环间隔打印指定内容，一个打印从1到52的数字，一个打印从A到Z的字母，打印输出如下：

1

2

A

3

4

B

......

51

52

Z

使用Lock实现代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadCommunicationTest {

private final Lock lock = new ReentrantLock();

private final Condition conditionA = lock.newCondition();
private final Condition conditionB = lock.newCondition();

private static char currentThread = 'A';

public static void main(String[] args) {

ThreadCommunicationTest test = new ThreadCommunicationTest();

ExecutorService service = Executors.newCachedThreadPool();

service.execute(test.new RunnableA());
service.execute(test.new RunnableB());

service.shutdown();

}

private class RunnableA implements Runnable {
public void run() {
for (int i = 1; i <= 52; i++) {
lock.lock();

try {
while (currentThread != 'A') {
try {
conditionA.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

System.out.println(i);
if (i % 2 == 0) {
currentThread = 'B';
conditionB.signal();
}
} finally {
lock.unlock();
}
}

}

}

private class RunnableB implements Runnable {
public void run() {
for (char c = 'A'; c <= 'Z'; c++) {
lock.lock();
try {
while (currentThread != 'B') {
try {
conditionB.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

System.out.println(c);
currentThread = 'A';
conditionA.signal();
} finally {
lock.unlock();
}
}

}

}
}

使用wait/notify实现代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadCommunicationTest2 {

private static char currentThread = 'A';
private final Object t = new Object(); //使用一个同步对象保证两个线程之间每一时刻只有一个线程工作

public static void main(String[] args) {
ThreadCommunicationTest2 test = new ThreadCommunicationTest2();
ExecutorService service = Executors.newCachedThreadPool();

service.execute(test.new RunnableA());
service.execute(test.new RunnableB());

service.shutdown();
}

private class RunnableA implements Runnable {
public void run() {
for (int i = 1; i <= 52; i++) {
synchronized (t) {
if(currentThread != 'A'){
try {
t.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(i);
if (i % 2 == 0) {
currentThread = 'B';
t.notifyAll();
}
}
}
}
}

private class RunnableB implements Runnable {
public void run() {
for (char c = 'A'; c <= 'Z'; c++) {
synchronized (t) {
if(currentThread != 'B'){
try {
t.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(c);
currentThread = 'A';
t.notifyAll();
}
}
}
}

}

使用Semaphore信号量的代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class ThreadCommunicationTest3 {

private final Semaphore semap = new Semaphore(1);//创建一个只有1个许可的信号量，保证两个线程间每一时刻只有一个在工作

private static char currentThread = 'A';

public static void main(String[] args) {

ThreadCommunicationTest3 test = new ThreadCommunicationTest3();

ExecutorService service = Executors.newCachedThreadPool();

service.execute(test.new RunnableA());
service.execute(test.new RunnableB());

service.shutdown();

}

private class RunnableA implements Runnable {
public void run() {
for (int i = 1; i <= 52; i++) {
try {
semap.acquire();
while (currentThread != 'A') {
semap.release();
}
System.out.println(i);
if (i % 2 == 0) {
currentThread = 'B';
}
} catch (Exception e) {
e.printStackTrace();
} finally {
semap.release();
}
}
}
}

private class RunnableB implements Runnable {
public void run() {
for (char c = 'A'; c <= 'Z'; c++) {
try {
semap.acquire();
while (currentThread != 'B') {
semap.release();
}
System.out.println(c);
currentThread = 'A';
} catch (Exception e) {
e.printStackTrace();
} finally {
semap.release();
}
}
}

}
}