多线程设计模式：第六篇 - ThreadLocal和Active Object模式

Posted 2021-01-18

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了多线程设计模式：第六篇 - ThreadLocal和Active Object模式相关的知识，希望对你有一定的参考价值。

一，ThreadLocal

Java 中的 ThreadLocal 类给多线程编程提供了一种可以让每个线程具有自己独立空间的机制，在这个空间内存储的数据是线程特有的，不对外共享。

ThreadLocal 类提供了 set() 和 get() 方法用于设置和获取线程特有数据，且 ThreadLocal 支持泛型，这样可以通过参数来指定要存储数据的类型。

二，Active Object模式

Active Object模式的主要目的是实现方法调用和执行分离到不同的线程中，这样可以提高调用方的响应速度，同时执行方的执行策略对调用方透明，达到双方互不干扰。这和之前我们说的生产者-消费者模式，Worker-Thread模式非常相似。

下面的程序示例，我们选择使用 juc 包中的 Executor 框架来实现一个Active Object模式：

/**
 * @author koma <[email protected]>
 * @date 2018-11-05
 */
public class Main {
    public static void main(String[] args) {
        ActiveObject activeObject = ActiveObjectFactory.createActiveObject();
        try {
            new MakerClientThread("Alice", activeObject).start();
            new MakerClientThread("Bobby", activeObject).start();
            Thread.sleep(5000);
        } catch (RejectedExecutionException e) {
        } catch (InterruptedException e) {
        } finally {
            activeObject.shutdown();
        }
    }
}

public interface ActiveObject {
    public abstract Future<String> makeString(int count, char fillchar);
    public abstract void displayString(String s);
    public abstract void shutdown();
}

public class ActiveObjectFactory {
    public static ActiveObject createActiveObject() {
        return new ActiveObjectImpl();
    }
}

public class ActiveObjectImpl implements ActiveObject {
    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

    @Override
    public Future<String> makeString(final int count, final char fillchar) {
        class MakeStringRequest implements Callable<String> {
            @Override
            public String call() throws Exception { //请求的执行在另外一个线程中异步执行
                char[] buffer = new char[count];
                for (int i = 0; i < count; i++) {
                    buffer[i] = fillchar;
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                return new String(buffer);
            }
        }
        return executorService.submit(new MakeStringRequest()); //提交请求并马上返回
    }

    @Override
    public void shutdown() {
        executorService.shutdown();
    }
}

public class MakerClientThread extends Thread {
    private final ActiveObject activeObject;
    private final char fillchar;

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

    @Override
    public void run() {
        try {
            for (int i = 0; true; i++) {
                //使用 Future 模式获取数据
                Future<String> future = activeObject.makeString(i, fillchar);
                Thread.sleep(100);
                String value = future.get();
                System.out.println(Thread.currentThread().getName()+": value = "+value);
            }
        } catch (InterruptedException e) {
        } catch (ExecutionException e) {
        }
    }
}