线程交替打印的题经常出现，总结一下：
一、两个线程交替打印0~100的奇偶数
/*
* 1.wait和notify都是Object类的方法。
* 2.wait和notify必须要在synchronized代码块中执行，否则会抛异常。
*/
public class WaitNotifyPrint {
private static int count = 0;
//两个线程竞争该对象锁
private static final Object lock = new Object();
public static void main(String[] args) throws InterruptedException {
new Thread(new TurningRunner(), "偶数").start();
new Thread(new TurningRunner(), "奇数").start();
}
//1. 拿到锁直接就打印。
//2. 打印完，唤醒其他线程，自己就休眠。
static class TurningRunner implements Runnable {
@Override
public void run() {
while (count <= 100) {
synchronized (lock) {
//拿到锁就打印
System.out.println(Thread.currentThread().getName() + ":" + count++);
//打印完，唤醒其他线程
lock.notify();
//如果任务还没结束，就调用wait()让出当前的锁
if (count <= 100) {
try {
//自己休眠
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}
二、生产者消费者
/*
* 用EventStorage模拟仓库，Producer代表生产者，Consumer代表消费者，
* 生产者和消费者共同对仓库进行协作。
*/
public class ProducerConsumerModel {
public static void main(String[] args) {
//初始化仓库
EventStorage eventStorage = new EventStorage();
//用仓库初始化生产者
Producer producer = new Producer(eventStorage);
//用仓库初始化消费者
Consumer consumer = new Consumer(eventStorage);
//启动生产者和消费者
new Thread(producer).start();
new Thread(consumer).start();
}
}
class Producer implements Runnable {
private EventStorage storage;
public Producer(
EventStorage storage) {
this.storage = storage;
}
@Override
public void run() {
//生产者往仓库中生产100个对象（此时消费者也在消费）
for (int i = 0; i < 100; i++) {
storage.put();
}
}
}
class Consumer implements Runnable {
private EventStorage storage;
public Consumer(
EventStorage storage) {
this.storage = storage;
}
@Override
public void run() {
//消费者循环消费仓库中的对象（此时生产者也在生产）
for (int i = 0; i < 100; i++) {
storage.take();
}
}
}
class EventStorage {
private int maxSize;
//用Date来模拟对象
private LinkedList<Date> storage;
//注意看构造方法定义仓库大小为10，并且用LinkedList来存储对象
public EventStorage() {
maxSize = 10;
storage = new LinkedList<>();
}
public synchronized void put() {
//仓库满了就休眠
while (storage.size() == maxSize) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//仓库没满就添加并通知消费者
storage.add(new Date());
System.out.println("仓库里有了" + storage.size() + "个产品。");
notify();
}
public synchronized void take() {
//仓库空了就休眠
while (storage.size() == 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//没空就取数据，poll方法代表检索并删除并通知生产者
System.out.println("拿到了" + storage.poll() + "，现在仓库还剩下" + storage.size());
notify();
}
}
三、交替打印ABC
方法一、synchronized
public class ABC {
public static class ThreadPrinter implements Runnable {
private String name;
private Object prev;
private Object self;
private ThreadPrinter(String name,Object prev,Object self){
this.name=name;
this.prev=prev;
this.self=self;
}
@Override
public void run() {
while (true){
synchronized (prev){
synchronized (self){
System.out.println(name);
self.notifyAll();
}
try{
prev.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
public static void main(String[] args) throws InterruptedException {
Object a = new Object();
Object b = new Object();
Object c = new Object();
ThreadPrinter pa=new ThreadPrinter("A",c,a);
ThreadPrinter pb=new ThreadPrinter("B",a,b);
ThreadPrinter pc=new ThreadPrinter("C",b,c);
//保证ABC顺序执行
new Thread(pa).start();
Thread.sleep(10);
new Thread(pb).start();
Thread.sleep(10);
new Thread(pc).start();
Thread.sleep(10);
}
}
}
方法二、ReentrantLock
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ABC2 {
private static Lock lock= new ReentrantLock();
private static int state=0;
static class ThreadA extends Thread{
@Override
public void run() {
while(true) {
try {
lock.lock();
while (state % 3 == 0) {
System.out.println("A");
state++;
}
} finally {
lock.unlock();
}
}
}
}
static class ThreadB extends Thread{
@Override
public void run() {
while(true) {
try {
lock.lock();
while (state % 3 == 1) {
System.out.println("B");
state++;
}
} finally {
lock.unlock();
}
}
}
}
static class ThreadC extends Thread{
@Override
public void run() {
while(true) {
try {
lock.lock();
while (state % 3 == 2) {
System.out.println("C");
state++;
}
} finally {
lock.unlock();
}
}
}
}
public static void main(String[] args) {
new ThreadA().start();
new ThreadB().start();
new ThreadC().start();
}
}
方法三、信号量
public class ABC3 {
private static Semaphore A =new Semaphore(1);
private static Semaphore B =new Semaphore(0);
private static Semaphore C =new Semaphore(0);
static class ThreadA extends Thread{
@Override
public void run() {
try {
while(true){
A.acquire();
System.out.println("A");
B.release();
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
static class ThreadB extends Thread{
@Override
public void run() {
try {
while(true){
B.acquire();
System.out.println("B");
C.release();
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
static class ThreadC extends Thread{
@Override
public void run() {
try {
while(true){
C.acquire();
System.out.println("C");
A.release();
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
new ThreadA().start();
new ThreadB().start();
new ThreadC().start();
}
}