`

Design Pattern: Thread-Specific Storage 模式

    博客分类:
  • J2SE
阅读更多

无论如何,要编写一个多执行绪安全(thread-safe)的程式总是困难的,为了使用的共用资源,您必须小心的对共用资源进行同步,同步带来一定的效能延迟,而另一方面,在处理同步的时候,又要注意物件的锁定与释放,避免产生死结,种种因素都使得编写多执行绪程式变得困难。

Thread-Specific Storage模式尝试从另一个角度来解释多执行绪共用资源的问题,其思考点很简单,即然共用资源这么困难,那么就干脆不要共用,何不为每个执行绪创造一个资源的复本,将每一个执行绪存取资料的行为加以隔离,其实现的方法,就是给予每一个执行绪一个特定空间来保管该执行绪所独享的资源,也因此而称之为 Thread- Specific Storage模式。

在Java中可以使用java.lang.ThreadLocal来实现这个模式,这个类别是从1.2之后开始提供,不过先来看看,如何自行实现一个简单的ThreadLocal类别:

  • ThreadLocal.java
import java.util.*;

public class ThreadLocal {
    private Map storage = 
                Collections.synchronizedMap(new HashMap());

    public Object get() {
        Thread current = Thread.currentThread();
        Object o = storage.get(current);

        if(o == null && !storage.containsKey(current)) {
            o = initialValue();
            storage.put(current, o);
        }

        return o;
    }

    public void set(Object o) {
        storage.put(Thread.currentThread(), o);
    }

    public Object initialValue() {
        return null;
    }
} 


可以看到程式中使用执行绪本身作为key值,并将所获得的资源放在Map物件中,如果第一次使用get(),也配置一个空间给执行绪,而 initialValue()可以用来设定什么样的初值要先储存在这个空间中,在这边先简单的设定为null。

现在假设有一个原先在单执行绪环境下的资源SomeResource,现在考虑要该其在多执行绪环境下使用,若不想考虑复杂的执行绪共用互斥问题,此时可以使用ThreadLocal类别来使用SomeResource,例如:

  • Resource.java
public class Resource {
    private static final ThreadLocal threadLocal = 
                                        new ThreadLocal();

    public static SomeResource getResource() {
        SomeResource resource =
                        (SomeResource) threadLocal.get();

        if(resource == null) {
            resource = new SomeResource();
            threadLocal.set(resource);
        }

        return resource;
    }
} 


上面所实作的ThreadLocal类别只是一个简单的示范,您可以使用java.lang.ThreadLocal来实现Thread- Specific Storage模式,以获得更好的效能,在这边简单的示范一个Log程式,它可以记录每个执行绪的活动,所使用的是 java.util.logging中的类别:

  • SimpleThreadLogger.java
import java.io.*;
import java.util.logging.*;                            
 
public class SimpleThreadLogger {
    private static final ThreadLocal threadLocal = 
                                         new ThreadLocal();

    public static void log(String msg) {
        getThreadLogger().log(Level.INFO, msg);
    }

    private static Logger getThreadLogger() {
        Logger logger = (Logger) threadLocal.get();

        if(logger == null) {
            try {
                logger = Logger.getLogger(
                           Thread.currentThread().getName());
                // Logger 预设是在主控台输出
                // 我们加入一个档案输出的Handler
                // 它会输出XML的记录文件
                logger.addHandler(
                    new FileHandler(
                           Thread.currentThread().getName() 
                           + ".log"));
            }
            catch(IOException e) {}

            threadLocal.set(logger);
        }

        return logger;
    }
} 


可以使用下面这个程式来测试:

  • LoggerTest.java
public class LoggerTest {
    public static void main(String[] args) {
        new TestThread("thread1").start();
        new TestThread("thread2").start();
        new TestThread("thread3").start();
    }
}

class TestThread extends Thread {
    public TestThread(String name) {
        super(name);
    }

    public void run() {
        for(int i = 0; i < 10; i++) {
            SimpleThreadLogger.log(getName() + 
                                     ": message " + i);
            try {
                Thread.sleep(1000);
            }
            catch(Exception e) {
                SimpleThreadLogger.log(e.toString());
            }
        }
    }
} 


执行LoggerTest可以在主控台上看到输出,并可以在同一目录下找到三个log档,分别记录了三个执行绪的活动,透过 ThreadLocal,不用撰写复杂的执行绪共用互斥逻辑。

Thread-Specific Storage模式的意义之一,就是“有时不共用是好的”,如果共用会产生危险,那就不要共用,当然,这种方式所牺牲掉的就是空间,您必须为每一个执行绪保留它们独立的空间,这是一种以空间换取时间与安全性的方法。

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics