多线程设计模式-Active Objects设计模式

Active Objects设计模式

测试异步消息的主动对象

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:ActiveObjectTest
 * @Author:linianest
 * @CreateTime:2021/1/4 16:17
 * @version:1.0
 * @Description TODO: 测试异步消息的主动对象
 */
public class ActiveObjectTest {
    public static void main(String[] args) {
        final ActiveObject activeObject = ActiveObjectFactory.createActiveObject();
        new MakerClientThread(activeObject,"Alice").start();
        new MakerClientThread(activeObject,"Baobo").start();

        new DisPlayClientThread("Chris",activeObject).start();
    }
}

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:MakerClientThread
 * @Author:linianest
 * @CreateTime:2021/1/4 16:11
 * @version:1.0
 * @Description TODO:
 */
public class MakerClientThread extends Thread {
    private final ActiveObject activeObject;
    private final char fillChar;

    public MakerClientThread(ActiveObject activeObject, String name) {
        super(name);
        this.activeObject = activeObject;
        this.fillChar = name.charAt(0);
    }

    @Override
    public void run() {
        try {
            for (int i = 0; true; i++) {
                Result result = activeObject.makeString(i + 1, fillChar);
                Thread.sleep(2_0);
                 String value = (String) result.getResultValue();
                System.out.println(Thread.currentThread().getName() + ": value=" + value);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:DisPlayClientThread
 * @Author:linianest
 * @CreateTime:2021/1/4 16:07
 * @version:1.0
 * @Description TODO:
 */
public class DisPlayClientThread extends Thread {
    private final ActiveObject activeObject;

    public DisPlayClientThread(String name, ActiveObject activeObject) {
        super(name);
        this.activeObject = activeObject;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; true; i++) {
                String text = Thread.currentThread().getName() + "=>" + i;
                activeObject.displayString(text);
                Thread.sleep(2_00);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

定义接口接受异步消息的主动对象

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:ActiveObject
 * @Author:linianest
 * @CreateTime:2021/1/4 15:09
 * @version:1.0
 * @Description TODO: 接受异步消息的主动对象
 */
public interface ActiveObject {
    Result  makeString(int count,char fillChar);

    void displayString(String text);
}

返回的结果

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:Result
 * @Author:linianest
 * @CreateTime:2021/1/4 15:20
 * @version:1.0
 * @Description TODO: 返回的结果
 */
public interface Result {
    Object getResultValue();
}

Future设计模式的结果

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:FutureResult
 * @Author:linianest
 * @CreateTime:2021/1/4 15:28
 * @version:1.0
 * @Description TODO: Future设计模式的结果
 */

/**
 * 获取结果的线程，如果结果没有出来，就wait住，如果结果出来就返回真的结果
 */
public class FutureResult implements Result {
    private Result result;
    private boolean ready=false;
    public synchronized void setResult(Result result){
        this.result=result;
        this.ready=true;
        this.notifyAll();
    }
    @Override
    public synchronized Object getResultValue() {
        while (!ready){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return this.result.getResultValue();
    }
}

真正的结果

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:RealResult
 * @Author:linianest
 * @CreateTime:2021/1/4 15:24
 * @version:1.0
 * @Description TODO: 真正的结果
 */
public class RealResult implements Result{
    private final Object resultValue;

    public RealResult(Object resultValue) {
        this.resultValue = resultValue;
    }

    @Override
    public Object getResultValue() {
        return resultValue;
    }
}

对应ActiveObject的每一个方法

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:MethodRequest
 * @Author:linianest
 * @CreateTime:2021/1/4 15:17
 * @version:1.0
 * @Description TODO:对应ActiveObject的每一个方法
 */

/**
 * 对应ActiveObject的每一个方法
 */
public abstract class MethodRequest {

    protected final Servant servant;
    protected final FutureResult futureResult;

    public MethodRequest(Servant servant, FutureResult futureResult) {
        this.servant = servant;
        this.futureResult = futureResult;
    }

    public abstract void execute();
}

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:DisplayStringRequest
 * @Author:linianest
 * @CreateTime:2021/1/4 15:41
 * @version:1.0
 * @Description TODO:
 */
public class DisplayStringRequest extends MethodRequest {
    private final String text;

    public DisplayStringRequest(Servant servant, final String text) {
        super(servant, null);
        this.text = text;
    }

    @Override
    public void execute() {

        this.servant.displayString(text);
    }
}

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:MakeStringRequest
 * @Author:linianest
 * @CreateTime:2021/1/4 15:34
 * @version:1.0
 * @Description TODO:负责makeString 方法
 */

/**
 * 负责makeString 方法
 */
public class MakeStringRequest extends MethodRequest {
    private final int count;
    private final char fillChar;

    public MakeStringRequest(Servant servant, FutureResult futureResult, int count, char fillChar) {
        super(servant, futureResult);
        this.count = count;
        this.fillChar = fillChar;
    }

    @Override
    public void execute() {

        Result result = servant.makeString(count, fillChar);
        futureResult.setResult(result);
    }
}

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:MakerClientThread
 * @Author:linianest
 * @CreateTime:2021/1/4 16:11
 * @version:1.0
 * @Description TODO:
 */
public class MakerClientThread extends Thread {
    private final ActiveObject activeObject;
    private final char fillChar;

    public MakerClientThread(ActiveObject activeObject, String name) {
        super(name);
        this.activeObject = activeObject;
        this.fillChar = name.charAt(0);
    }

    @Override
    public void run() {
        try {
            for (int i = 0; true; i++) {
                Result result = activeObject.makeString(i + 1, fillChar);
                Thread.sleep(2_0);
                 String value = (String) result.getResultValue();
                System.out.println(Thread.currentThread().getName() + ": value=" + value);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

真正做事的

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:Servamt
 * @Author:linianest
 * @CreateTime:2021/1/4 15:19
 * @version:1.0
 * @Description TODO: 真正做事的
 */
class Servant implements ActiveObject {
    /**
     * 返回真正的结果
     * @param count
     * @param fillChar
     * @return
     */
    @Override
    public Result makeString(int count, char fillChar) {

        char[] buf = new char[count];
        for (int i = 0; i < count; i++) {
            buf[i]=fillChar;
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return new RealResult(new String(buf));
    }

    /**
     * 展示结果
     * @param text
     */
    @Override
    public void displayString(String text) {
        try {
            System.out.println("Display:"+text);
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:SchedulerThread
 * @Author:linianest
 * @CreateTime:2021/1/4 15:50
 * @version:1.0
 * @Description TODO:
 */
public class SchedulerThread extends Thread {
    private final ActivationQueue activationQueue;


    public SchedulerThread(ActivationQueue activationQueue) {
        this.activationQueue = activationQueue;
    }

    public  void invoke(MethodRequest request){
        this.activationQueue.put(request);
    }

    @Override
    public void run() {
        while (true){
            activationQueue.take().execute();
        }
    }
}

package com.ln.concurrent.chapter18;

import java.util.LinkedList;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:ActivationQueue
 * @Author:linianest
 * @CreateTime:2021/1/4 15:44
 * @version:1.0
 * @Description TODO:
 */
public class ActivationQueue {
    private final static int MAX_METHOD_REQUEST_QUEUE_SIZE = 100;

    private final LinkedList<MethodRequest> methodQueue;

    public ActivationQueue() {
        this.methodQueue = new LinkedList<>();
    }

    public synchronized void put(MethodRequest request) {
        while (methodQueue.size() >= MAX_METHOD_REQUEST_QUEUE_SIZE) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.methodQueue.addLast(request);
        this.notifyAll();
    }

    public synchronized MethodRequest take() {
        while (methodQueue.isEmpty()) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        final MethodRequest methodRequest = methodQueue.removeFirst();
        this.notifyAll();
        return methodRequest;
    }
}

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:ActiveObjcetProxy
 * @Author:linianest
 * @CreateTime:2021/1/4 15:57
 * @version:1.0
 * @Description TODO:ActiveObjcet代理
 */
class ActiveObjcetProxy implements ActiveObject {

    private final SchedulerThread schedulerThread;
    private final Servant servant;

    public ActiveObjcetProxy(SchedulerThread schedulerThread, Servant servant) {
        this.schedulerThread = schedulerThread;
        this.servant = servant;
    }

    @Override
    public Result makeString(int count, char fillChar) {
        FutureResult futureResult = new FutureResult();
        schedulerThread.invoke(new MakeStringRequest(servant, futureResult, count, fillChar));
        return futureResult;
    }

    @Override
    public void displayString(String text) {
        schedulerThread.invoke(new DisplayStringRequest(servant, text));
    }
}

package com.ln.concurrent.chapter18;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter18
 * @Name:ActiveObjectFactory
 * @Author:linianest
 * @CreateTime:2021/1/4 16:02
 * @version:1.0
 * @Description TODO:
 */
public final class ActiveObjectFactory {
    private ActiveObjectFactory() {

    }

    public static ActiveObject createActiveObject() {
        Servant servant = new Servant();
        ActivationQueue queue = new ActivationQueue();
        SchedulerThread schedulerThread = new SchedulerThread(queue);
        ActiveObjcetProxy proxy = new ActiveObjcetProxy(schedulerThread, servant);
        schedulerThread.start();
        return proxy;
    }
}