Background
相关概念
什么是多线程
我们把组成程序(Program)各个部分称为线程(Thread)。也可以说，线程就是程序中轻量级的进程(Process)。
多线程(Multithreading)是Java的一个特性，它可以允许一个程序的多个部分(也就是线程)并发地执行，以达到最大程度利用CPU的目的。
Multithreading is a Java feature that allows concurrent execution of two or more parts of a program for maximum utilization of CPU. Each part of such program is called a thread. So, threads are light-weight processes within a process.
线程的状态
轮询
Samples
我们把循环执行某个逻辑判断，直到判断条件为true才执行判断体中的逻辑，叫做轮询(Polling)。轮询是会浪费一定的CPU资源的。
The process of testing a condition repeatedly till it becomes true is known as polling.Polling is usually implemented with the help of loops to check whether a particular condition is true or not. If it is true, certain action is taken. This waste many CPU cycles and makes the implementation inefficient.
-- https://www.geeksforgeeks.org/inter-thread-communication-java/
下面提供一个轮询的实现示例。
Message：
isAvailable初始值是false，设置为true以后执行轮询体。
注意要使用线程安全的AtomicBoolean，如果使用boolean，在多线程情况下会有意想不到的结果。
import lombok.Getter;
import lombok.Setter;
import java.util.concurrent.atomic.AtomicBoolean;
@Setter
@Getter
public class Message {
private AtomicBoolean isAvailable = new AtomicBoolean(false);
private String msg;
public Message(String str) {
this.msg = str;
}
}
PollingWaiter：
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class PollingWaiter implements Runnable {
private Message msg;
public PollingWaiter(Message m) {
this.msg = m;
}
@Override
public void run() {
String name = Thread.currentThread().getName();
synchronized (msg) {
int count = 0;
System.out.println(name + " : waiter starting at time: " + LocalDateTime.now().format(DateTimeFormatter.ISO_TIME));
while (!msg.getIsAvailable().get()) {
count++;
}
System.out.println(name + " : msg is available at time: " + LocalDateTime.now().format(DateTimeFormatter.ISO_TIME));
System.out.println(name + " : msg is available after count: " + count);
System.out.println(name + " : processed: " + msg.getMsg());
}
}
}
执行测试：
休眠3秒以后，再执行轮询体内的代码。
import java.util.concurrent.atomic.AtomicBoolean;
public class WaitNotifyTest {
public static void main(String[] args) {
testPolling();
}
public static void testPolling() {
Message msg = new Message("process it");
PollingWaiter waiter = new PollingWaiter(msg);
new Thread(waiter, "PollingWaiter").start();
try {
Thread.sleep(3000);
} catch (Exception e) {
e.printStackTrace();
}
msg.setIsAvailable(new AtomicBoolean(true));
System.out.println("over");
}
}
输出结果：
PollingWaiter : waiter starting at time: 14:26:08.482
over
PollingWaiter : msg is available at time: 14:26:11.402
PollingWaiter : msg is available after count: -69547606
PollingWaiter : processed: process it
wait 和 notify
除了轮询，Java通过wait 和 notify机制实现了线程间的通信。wait就是让执有某个对象的线程处于等待阻塞状态，而notify就是让等待阻塞中的线程重新获得CPU资源，再次进入运行状态。
由于wait 和 notify相关的方法实现在了java.lang.Object类中，因此所有的子类都可以使用这些方法。
wait 和 notify相关的方法需要在synchronized代码块中执行。
方法介绍
下面简要介绍一下这些方法：
- wait()
wait()方法会导致当前线程从执行状态改为待执行状态，一直到另外一个线程为当前对象执行notify()或者notifyAll()方法。
- wait(long timeout)
与wait()方法的不同点是，如果timeout时间到了以后，还没有前对象执行notify()或者notifyAll()，则线程自动开始执行。
值得注意的是执行wait(0)和wait()的效果是一样的。
- wait(long timeout, int nanos)
与wait(long timeout)相比，此方法提供了等待超时设置的更高的精度，精确到了纳秒。
1毫秒 = 1,000,000 纳秒。
- notify()
对于等待此对象的监视器的所有线程，执行notify()会随机唤醒一个线程。
- notifyAll()
相比与notify()，此方法会唤醒所有等待该对象的监视器的线程。
示例
在上面示例代码的基础上，增加如下代码实现。
Waiter:
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Waiter implements Runnable{
private Message msg;
public Waiter(Message m){
this.msg=m;
}
@Override
public void run() {
String name = Thread.currentThread().getName();
synchronized (msg) {
try{
System.out.println(name+" : waiting to get notified at time:"+ LocalDateTime.now().format(DateTimeFormatter.ISO_TIME));
msg.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(name+" : waiter thread got notified at time:"+LocalDateTime.now().format(DateTimeFormatter.ISO_TIME));
//process the message now
System.out.println(name+" : processed: "+msg.getMsg());
}
}
}
Notifier：
public class Notifier implements Runnable {
private boolean isAll = true;
private Message msg;
public Notifier(Message msg, boolean isAll) {
this.msg = msg;
this.isAll = isAll;
}
@Override
public void run() {
String name = Thread.currentThread().getName();
System.out.println(name + " started");
try {
Thread.sleep(3000);
synchronized (msg) {
System.out.println(name + " : got the msg : "+msg.getMsg());
msg.setMsg(name + " : Notifier work done");
if (isAll) {
msg.notifyAll();
} else {
msg.notify();
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
WaitNotifyTest:
import java.util.concurrent.atomic.AtomicBoolean;
public class WaitNotifyTest {
public static void main(String[] args) {
//testPolling();
testNotify();
//testNotifyAll();
}
public static void testPolling() {
Message msg = new Message("process it");
PollingWaiter waiter = new PollingWaiter(msg);
new Thread(waiter, "PollingWaiter").start();
try {
Thread.sleep(3000);
} catch (Exception e) {
e.printStackTrace();
}
msg.setIsAvailable(new AtomicBoolean(true));
System.out.println("over");
}
public static void testNotify() {
Message msg = new Message("process it");
Waiter waiter1 = new Waiter(msg);
new Thread(waiter1, "waiter1").start();
Waiter waiter2 = new Waiter(msg);
new Thread(waiter2, "waiter2").start();
Notifier notifier = new Notifier(msg, false);
new Thread(notifier, "notifier").start();
System.out.println("All the threads are started");
}
public static void testNotifyAll() {
Message msg = new Message("process it");
Waiter waiter1 = new Waiter(msg);
new Thread(waiter1, "waiter1").start();
Waiter waiter2 = new Waiter(msg);
new Thread(waiter2, "waiter2").start();
Notifier notifier = new Notifier(msg, false);
new Thread(notifier, "notifier").start();
System.out.println("All the threads are started");
}
}
在启动两个线程同时执行wait方法的时候，会发现notify以后只有一个线程被唤醒了，而另一个线程则陷入了无尽地等待之中。
