亚洲国产区男人本色在线观看,亚洲精品一二三区,亚洲精品二区国产综合野狼

实现自己的Lock对象

DLevin — Mon, 10 Aug 2015 22:08:00 GMT

一直想好好学习concurrent包中的各个类的实玎ͼ�然而经常看了一点就因�ؓ其他事情�q�扰而放下了。发现这样太不利于自��q��成长了，因而最�q�打��潜心一件一件的完成自己惛_��习的东西�?br />
对concurrent包的学习打算先从Lock的实现开始，因而自然而然的就端�v了AbstractQueuedSynchronizer�Q�然而要��L��q�个�cȝ��源码�q�不是那么容易，因而我��开始问自己一个问题：如果自己要去实现�q�个一个Lock对象�Q�应该如何实现呢�Q?br />
要实现Lock对象�Q�首先理解什么是锁？我自�׃��~�程角度��单的理解�Q�所谓锁对象�Q�互斥锁�Q�就是它能保证一�ơ只有一个线�E�能�q�入它保护的临界区，如果有一个线�E�已�l�拿到锁对象�Q�那么其他对象必��让权等待，而在该线�E�退��个��界区旉��要唤醒等待列表中的其他线�E�。更学术一些，《计��机操作�pȝ��?/a>中对同步机制准则的归�U�I��P50�Q�：

�I�闲让进。当无进�E�处于��界区�Ӟ��表明临界资源处于�I�闲状态，应允�怸�个请求进入��界区的进�E�立卌��入自��q��临界区，以有效的利用临界资源�?/li>

忙则�{�待。当已有�q�程�q�入临界区时�Q�表明��界资源正在被讉K��Q�因而其他试图进入��界区的进�E�必��ȝ��待，以保证对临界��源的互斥讉K��?/li>

有限�{�待。对要求讉K��临界资源的进�E�，应保证在有限旉��内能�q�入自己的��界区�Q�以免陷�?#8220;�ȝ��”状态�?/li>

让权�{�待。当�q�程不能�q�入自己的��界区�Ӟ��应该释放处理机，以免�q�程陷入“忙等”状态�?/li>

说了那么多，其实对互斥锁很简单，只需要一个标��C��Q�如果该标记位�ؓ0�Q�表�C�没有被占用�Q�因而直接获得锁�Q�然后把该标��C��|��ؓ1�Q�此时其他线�E�发现该标记位已�l�是1�Q�因而需要等待。这里对�q�个标记位的比较�q�设值必��L��原子操作�Q�而在JDK5以后提供的atomic包里的工��L��可以很方便的提供�q�个原子操作。然而上面的四个准则应该漏了一点，即释��N��的线�E�（�q�程�Q�和得到锁的�U�程�Q�进�E�）应该是同一个，��像一把钥匙对应一把锁�Q�理想的�Q�，所以一个非常简单的Lock�c�d��以这么实玎ͼ�

public class SpinLockV1 {
    private final AtomicInteger state = new AtomicInteger(0);
    private volatile Thread owner; // �q�里owner字段可能存在中间��|��不可靠，因而其他线�E�不可以依赖�q�个字段的�?/span>

    public void lock() {
        while (!state.compareAndSet(0, 1)) { }
        owner = Thread.currentThread();
    }

    public void unlock() {
        Thread currentThread = Thread.currentThread();
        if (owner != currentThread || !state.compareAndSet(1, 0)) {
            throw new IllegalStateException("The lock is not owned by thread: " + currentThread);
        }
        owner = null;
    }
}

一个简单的��试�Ҏ��Q?br />

    @Test
    public void testLockCorrectly() throws InterruptedException {
        final int COUNT = 100;
        Thread[] threads = new Thread[COUNT];
        SpinLockV1 lock = new SpinLockV1();
        AddRunner runner = new AddRunner(lock);
        for (int i = 0; i < COUNT; i++) {
            threads[i] = new Thread(runner, "thread-" + i);
            threads[i].start();
        }

        for (int i = 0; i < COUNT; i++) {
            threads[i].join();
        }

        assertEquals(COUNT, runner.getState());
    }

    private static class AddRunner implements Runnable {
        private final SpinLockV1 lock;
        private int state = 0;

        public AddRunner(SpinLockV1 lock) {
            this.lock = lock;
        }

        public void run() {
            lock.lock();
            try {
                quietSleep(10);
                state++;
                System.out.println(Thread.currentThread().getName() + ": " + state);
            } finally {
                lock.unlock();
            }
        }

        public int getState() {
            return state;
        }
    }

然而这个SpinLock其实�q�不需要state�q�个字段�Q�因为owner的赋��g��否也是一�U�状态，因而可以用它作��Z��U�互斥状态：

public class SpinLockV2 {
    private final AtomicReference<Thread> owner = new AtomicReference<Thread>(null);

    public void lock() {
        final Thread currentThread = Thread.currentThread();
        while (!owner.compareAndSet(null, currentThread)) { }
    }

    public void unlock() {
        Thread currentThread = Thread.currentThread();
        if (!owner.compareAndSet(currentThread, null)) {
            throw new IllegalStateException("The lock is not owned by thread: " + currentThread);
        }
    }
}

�q�在操作�pȝ��中被定义为整形信号量�Q�然而整形信号量如果没拿到锁会一直处�?#8220;忙等”状态（没有遵��@有限�{�待和让权等待的准则�Q�，因而这�U�锁也叫Spin Lock�Q�在短暂的等待中它可以提升性能�Q�因为可以减��线�E�的切换�Q�concurrent包中的Atomic大部分都采用�q�种机制实现�Q�然而如果需要长旉��的等待，“忙等”会占用不必要的CPU旉��Q�从而性能会变的很差，�q�个时候就需要将没有拿到锁的�U�程攑ֈ��{�待列表中，�q�种方式在操作系�l�中也叫记录型信号量�Q�它遵��@了让权等待准则（当前没有实现有限�{�待准则�Q�。在JDK6以后提供了LockSupport.park()/LockSupport.unpark()操作�Q�可以将当前�U�程攑օ�一个等待列表或��一个线�E�从�q�个�{�待列表中唤醒。然而这个park/unpark的等待列表是一个全局的等待列表，在unpartk的时候还是需要提供需要唤醒的Thread对象�Q�因而我们需要维护自��q��{�待列表�Q�但是如果我们可以用JDK提供的工��L��ConcurrentLinkedQueue�Q�就非常�Ҏ��实现�Q�如LockSupport文��中给出来�?a >代码事例�Q?br />

class FIFOMutex {
   private final AtomicBoolean locked = new AtomicBoolean(false);
   private final Queue<Thread> waiters = new ConcurrentLinkedQueue<Thread>();

   public void lock() {
     boolean wasInterrupted = false;
     Thread current = Thread.currentThread();
     waiters.add(current);

     // Block while not first in queue or cannot acquire lock
     while (waiters.peek() != current || !locked.compareAndSet(false, true)) {
        LockSupport.park(this);
        if (Thread.interrupted()) // ignore interrupts while waiting
          wasInterrupted = true;
     }

     waiters.remove();
     if (wasInterrupted)          // reassert interrupt status on exit
        current.interrupt();
   }

   public void unlock() {
     locked.set(false);
     LockSupport.unpark(waiters.peek());
   }
}

在该代码事例中，有一个线�E�等待队列和锁标记字�D�，每次调用lock时先��当前线�E�放入这个等待队列中�Q�然后拿出队列头�U�程对象�Q�如果该�U�程对象正好是当前线�E�，�q�且成功使用CAS方式讄��locked字段�Q�这里需要两个同时满��I��因�ؓ可能出现一个线�E�已�l�从队列中移除了但还没有unlock�Q�此时另一个线�E�调用lock�Ҏ��Q�此旉��列头的线�E�就是第二个�U�程�Q�然而由于第一个线�E�还没有unlock或者正在unlock�Q�因而需要��用CAS原子操作来判断是否要park�Q�，表示该线�E�竞争成功，获得锁，否则��当前线�E�park�Q�这里之所以要攑֜� while循环中，因�ؓpark操作可能无理��p��?spuriously)�Q�如文��中给出的描述�Q?br />

LockSupport.park()

public static void park(Object blocker)

Disables the current thread for thread scheduling purposes unless the permit is available.

If the permit is available then it is consumed and the call returns immediately; otherwise the current thread becomes disabled for thread scheduling purposes and lies dormant until one of three things happens:

Some other thread invokes unpark with the current thread as the target; or
Some other thread interrupts the current thread; or
The call spuriously (that is, for no reason) returns.

This method does not report which of these caused the method to return. Callers should re-check the conditions which caused the thread to park in the first place. Callers may also determine, for example, the interrupt status of the thread upon return.

Parameters:: blocker - the synchronization object responsible for this thread parking
Since:: 1.6

我在实现自己的类时就被这�?#8220;无理��p��?#8221;坑了好久。对于已�l�获得锁的线�E�，��该�U�程从等待队列中�U�除�Q�这里由于ConcurrentLinkedQueue是线�E�安全的�Q�因而能保证每次都是队列头的�U�程得到锁，因而在得到锁匙��队列头�U�除。unlock逻辑比较��单，只需要将locked字段打开�Q�设�|��ؓfalse�Q�，唤醒�Q�unpark�Q�队列头的线�E�即可，然后该线�E�会�l�箋在lock�Ҏ��的while循环中��l�竞争unlocked字段�Q��ƈ��它自己从线�E�队列中�U�除表示获得锁成功。当然安全�v见，最好在unlock中加入一些验证逻辑�Q�如解锁的线�E�和加锁的线�E�需要相同�?br />
然而本文的目的是自己实��C��个Lock对象�Q�即只��用一些基本的操作�Q�而不使用JDK提供的Atomic�c�d��ConcurrentLinkedQueue。类似的首先我们也需要一个队列存攄��待线�E�队列（公��^赯��Q��用先�q�先出队列）�Q�因而先定义一个Node对象用以构成�q�个队列�Q?br />

    protected static class Node {
        volatile Thread owner;
        volatile Node prev;
        volatile Node next;

        public Node(Thread owner) {
            this.owner = owner;
            this.state = INIT;
        }

        public Node() {
            this(Thread.currentThread());
        }
    }

��单�v见，队列头是一个�v点的placeholder�Q�每个调用lock的线�E�都先将自己竞争攑օ��q�个队列��，每个队列头后一个线�E�（Node�Q�即是获得锁的线�E�，所以我们需要有head Node字段用以快速获取队列头的后一个Node�Q�而tail Node字段用来快速插入新的Node�Q�所以关键在于如何线�E�安全的构徏�q�个队列�Q�方法还是一��L��Q��用CAS操作�Q�即CAS�Ҏ��自��p��|�成tail��|��然后重新构徏�q�个列表�Q?br />

    protected boolean enqueue(Node node) {
        while (true) {
            final Node preTail = tail;
            node.prev = preTail;
            if (compareAndSetTail(preTail, node)) {
                preTail.next = node;
                return node.prev == head;
            }
        }
    }

在当前线�E�Node以线�E�安全的方式攑օ��q�个队列后，lock实现相对��比较简单了�Q�如果当前Node是的前驱是head�Q�该�U�程获得锁，否则park当前�U�程�Q�处理park无理��p��回的问题�Q�因而将park攑օ�while循环中（该实现是一个不可重入的实现�Q�：

    public void lock() {
        // Put the latest node to a queue first, then check if the it is the first node
        // this way, the list is the only shared resource to deal with
        Node node = new Node();
        if (enqueue(node)) {
            current = node.owner;
        } else {
            while (node.prev != head) {
                LockSupport.park(this); // This may return "spuriously"!!, so put it to while
            }
            current = node.owner;
        }
    }

unlock的实现需要考虑多种情况�Q�如果当前Node(head.next)有后驱，那么直接unpark该后驱即可；如果没有�Q�表�C�当前已�l�没有其他线�E�在�{�待队列中，然而在�q�个判断�q�程中可能会有其他线�E�进入，因而需要用CAS的方式设�|�tail�Q�如果设�|�失败，表示此时有其他线�E�进入，因而需要将该新�q�入的线�E�unpark从而该新进入的�U�程在调用park后可以立卌��回（�q�里的CAS和enqueue的CAS都是对tail操作�Q�因而能保证状态一��_��Q?br />

    public void unlock() {
        Node curNode = unlockValidate();
        Node next = curNode.next;
        if (next != null) {
            head.next = next;
            next.prev = head;
            LockSupport.unpark(next.owner);
        } else {
            if (!compareAndSetTail(curNode, head)) {
                while (curNode.next == null) { } // Wait until the next available
                // Another node queued during the time, so we have to unlock that, or else, this node can never unparked
                unlock();
            } else {
                compareAndSetNext(head, curNode, null); // Still use CAS here as the head.next may already been changed
            }
        }
    }

具体的代码和��试�c�d��以参考查�?a >�q�里�?br />

其实直到自己写完�q�个�c�d��才直到者其实这是一个MCS锁的变种�Q�因而这个实现每个线�E�park在自�w�对应的node上，而由前一个线�E�unpark它；而AbstractQueuedSynchronizer是CLH锁，因�ؓ它的park由前��q��态决定，虽然它也是由前一个线�E�unpark它。具体可以参�?a >�q�里�?/p>

DLevin 2015-08-11 06:08 发表评论

ReferenceCountSet无锁实现

DLevin — Fri, 05 Dec 2014 16:29:00 GMT

摘要: 记得很久以前有一�ơ面试被问到如何�~�写无锁�E�序�Q�我当时觉得那个面试官脑子进水了�Q�我们确实可以在某些情况下减��锁的��用，但是怎么可能避免呢？当然我现在还是持�q�种观点�Q�在Java中，你可以有很多�Ҏ��减少锁的使用(臛_��在你自己的代码中看�v�?�Q? 1. 比如常见的可以��用volatile关键字来保证某个字段在一个线�E�中的更新对其他�U�程的可见性； 2.&nb... 阅读全文

DLevin 2014-12-06 00:29 发表评论

Java Cache�p�d��之Cache概述和Simple Cache

DLevin — Tue, 15 Oct 2013 15:46:00 GMT

前记�Q�最�q�公司在做的��目完全��Z��Cache�Q�Gemfire�Q�构��Z��一个类数据库的�pȝ��Q�自己做的一个小��目里用�q�Guava的Cache�Q�以前做�q�的��目中��用过EHCache�Q�既然和Cache那么有缘�Q�那��p��q�个��Z��好好研究一下Java中的Cache库。在Java�C�֌�中已�l�提供了很多Cache库实玎ͼ�具体可以参考http://www.open-open.com/13.htm�Q�这里只��x��自己用到的几个Cache库而且�q�几个库都比较具有代表性：Guava中提供的Cache是基于单JVM的简单实玎ͼ�EHCache��Hibernate�Q�也是基于单JVM的实玎ͼ�是对单JVM Cache比较完善的实玎ͼ�而Gemfire则提供了对分布式Cache的完善实现。这一�p�d��的文章主要关注在�q�几个Cache�pȝ��的实��C��Q�因而步探讨关于Cache的好处、何时用Cache�{�问题，�׃��他们都是��Z��内存的Cache�Q�因而也仅局限于�q�种�c�d��的Cache�Q�说实话�Q�我不知道有没有其他的Cache�pȝ��Q�比如基于文�Ӟ��囧）�?br />
记得我最早接触Cache是在大学学计��机�l�成原理的时候，�׃��CPU的速度要远大于内存的读取速度�Q��ؓ了提高CPU的效率，CPU会在内部提供�~�存区，该缓存区的读取速度和CPU的处理速度�c�M��Q�CPU可以直接从缓存区中读取数据，从而解决CPU的处理速度和内存读取速度不匹配的问题。缓存之所以能解决�q�个问题是基于程序的局部性原理，�?#8221;�E�序在执行时呈现出局部性规律，卛_��一�D�|��间内�Q�整个程序的执行仅限于程序中的某一部分。相应地�Q�执行所讉K��的存储空间也局限于某个内存区域。局部性原理又表现为：旉��局部性和�I�间局部性。时间局部性是指如果程序中的某条指令一旦执行，则不久之后该指��o可能再次被执行；如果某数据被讉K��Q�则不久之后该数据可能再�ơ被讉K��。空间局部性是指一旦程序访问了某个存储单元�Q�则不久之后。其附近的存储单元也��被讉K��?#8221;在实际工作中�Q�CPU先向�~�存��取数据，如果�~�存区已存在�Q�则��d��~�存中的数据�Q�命中）�Q�否则（失效�Q�，��内存中相应数据块蝲入缓存中�Q�以提高接下来的讉K��速度。由于成本和CPU大小的限�Ӟ��CPU只能提供有限的缓存区�Q�因而缓存区的大��是衡量CPU性能的重要指标之一�?br />
使用�~�存�Q�在CPU向内存更新数据时需要处理一个问题（写回�{�略问题�Q�，即CPU在更新数据时只更新缓存的数据�Q�write back�Q�写回，当缓存需要被替换时才��缓存中更新的值写回内存）�Q�还是CPU在更新数据时同时更新�~�存中和内存中的数据�Q�write through�Q�写通）。在写回�{�略中，��Z��减少内存写操作，�~�存块通常�q�设有一个脏位（dirty bit�Q�，用以标识该块在被载入之后是否发生�q�更新。如果一个缓存块在被�|�换回内存之前从未被写入�q�，则可以免��d��写操作；写回的优�Ҏ��节省了大量的写操作。这主要是因为，对一个数据块内不同单元的更新仅需一�ơ写操作卛_��完成。这�U�内存带宽上的节省进一步降低了能耗，因此颇适用于嵌入式�pȝ��。写通策略由于要�l�常和内存交互（有些CPU设计会在中间提供写缓冲器以缓解性能�Q�，因而性能较差�Q�但是它实现��单，而且能简单的�l�持数据一致性�?br />
在��Y件的�~�存�pȝ��中，一般是��Z��解决内存的访问速率和磁盘、网�l�、数据库�Q�属于磁盘或�|�络讉K��Q�单独列出来因�ؓ它的应用比较�q�泛�Q�等讉K��速率不匹配的问题�Q�对于内存缓存系�l�来��_��。但是由于内存大��和成本的限�Ӟ��我们又不能把所有的数据先加载进内存来。因而如CPU中的�~�存�Q�我们只能先��一部分数据保存在缓存中。此�Ӟ��对于�~�存�Q�我们一般要解决如下需求：

使用�l�定Key从Cache中读取Value倹{��CPU是通过内存地址来定位内存已获取相应内存中的��|��c�M��的在软�gCache中，需要通过某个Key值来标识相关的倹{��因而可以简单的认�ؓ软�g中的Cache是一个存储键值对的Map�Q�比如Gemfire中的Region��q��承自Map�Q�只是Cache的实现更加复杂�?/li>
当给定的Key在当前Cache不存在时�Q�程序员可以通过指定相应的逻辑从其他源�Q�如数据库、网�l�等源）中加载该Key对应的Value��|��同时��该��D��回。在CPU中，��Z��E�序局部性原理，一般是默认的加载接下来的一�D�内存块�Q�然而在软�g中，不同的需求有不同的加载逻辑�Q�因而需要用戯��己指定对应的加蝲逻辑�Q�而且一般来说也很难预知接下来要��d��的数据，所以只能一�ơ只加蝲一条纪录（对可预知的场景下当然可以扚w��加蝲数据�Q�只是此旉��要权衡当前操作的响应旉��问题�Q��?/li>
可以向Cache中写入Key�Q�Value键值对�Q�新增的�U�录或对原有的键值对的更斎ͼ�。就像CPU的写回策略中有写回和写通策略，有些Cache�pȝ��提供了写通接口。如果没有提供写通接口，�E�序员需要额外的逻辑处理写通策略。也可以如CPU中的Cache一��P��只当相应的键值对�U�d��Cache以后�Q�再��值写回到数据源，可以提供一个标��C��以决定要不要写回�Q�不�q�感觉这�U�实现比较复杂，代码的的耦合度也比较高，如果为提升写的速度�Q�采用异步写回即可，为防止数据丢失，可以使用Queue来存储）�?/li>
��给定Key的键值对�U�d��Cache�Q�或�l�定多个Key以批量移除，甚至清除整个Cache�Q��?/li>
配置Cache的最大��用率�Q�当Cache��过该��用率�Ӟ��可配�|�溢出策�?
1. 直接�U�除溢出的键值对。在�U�除时决定是否要写回已更新的数据到数据源�?/li>
2. ��溢出的溢出的键值对写到��盘中。在写磁盘时需要解军_��何序列化键值对�Q�如何存储序列化后的数据到磁盘中�Q�如何布局��盘存储�Q�如何解决磁盘碎片问题，如何从磁盘中扑֛�相应的键值对�Q�如何读取磁盘中的数据�ƈ方序列化�Q�如何处理磁盘溢出等问题�?/li>
3. 在溢出策略中�Q�除了如何处理溢出的键值对问题�Q�还需要处理如何选择溢出的键值对问题。这有点�c�M��内存的页面置换算法（其实内存也可以看作是对磁盘的Cache�Q�，一般��用的��法有：先进先出�Q�FIFO�Q�、最�q�最��用（LRU�Q�、最��用（LFU�Q�、Clock�|�换�Q�类LRU�Q�、工作集�{�算法�?/li>
对Cache中的键值对�Q�可以配�|�其生存旉��Q�以处理某些键值对在长旉��不被使用�Q�但是又没能溢出的问题（因�ؓ溢出�{�略的选择或者Cache没有到溢出阶�D�）�Q�以提前释放内存�?/li>
�Ҏ��些特定的键值对�Q�我们希望它能一直留在内存中不被溢出�Q�有些Cache�pȝ��提供PIN配置�Q�动态或静态）�Q�以��保该键值对不会被溢出�?/li>
提供Cache状态、命中率�{�统计信息，如磁盘大��、Cache大小、��^均查询时间、每�U�查询次数、内存命中次数、磁盘命中次数等信息�?/li>
提供注册Cache相关的事件处理器�Q�如Cache的创建、Cache的销毁、一条键值对的添加、一条键值对的更新、键值对溢出�{�事件�?/li>
�׃��引入Cache的目的就是�ؓ了提升程序的��d��性能�Q�而且一般Cache都需要在多线�E�环境下工作�Q�因而在实现时一般需要保证线�E�安全，以及提供高效的读写性能�?/li>

在Java中，Map是最��单的Cache�Q��ؓ了高效的在多�U�程环境中��用，可以使用ConcurrentHashMap�Q�这也正是我之前参与的一个项目中最开始的实现�Q�后来引入EHCache�Q�。�ؓ了语意更加清晰、保持接口的��单，下面我实��C��一个基于Map的最��单的Cache�pȝ��Q�用以演�C�Cache的基本��用方式。用户可以向它提供数据、查询数据、判断给定Key的存在性、移除给定的Key(s)、清除整个Cache�{�操作。以下是Cache的接口定义�?br />

public interface Cache {
    public String getName();
    public V get(K key);
    public Mapextends K, ? extends V> getAll(Iteratorextends K> keys);
    public boolean isPresent(K key);
    public void put(K key, V value);
    public void putAll(Mapextends K, ? extends V> entries);
    public void invalidate(K key);
    public void invalidateAll(Iteratorextends K> keys);
    public void invalidateAll();
    public boolean isEmpty();
    public int size();
    public void clear();
    public Mapextends K, ? extends V> asMap();
}

�q�个��单的Cache实现只是对HashMap的封装，之所以选择HashMap而不是ConcurrentHashMap是因为在ConcurrentHashMap无法实现getAll()�Ҏ��Q��ƈ且这里所有的操作我都加锁了，因而也不需要ConcurrentHashMap来保证线�E�安全问题；��Z��提升性能�Q�我使用了读写锁�Q�以提升�q�发查询性能。因��Z��码比较简单，所以把所有代码都贴上了（懒得整理了。。。。）�?br />

public class CacheImpl implements Cache {
    private final String name;
    private final HashMap cache;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();

    public CacheImpl(String name) {
        this.name = name;
        cache = new HashMap();
    }

    public CacheImpl(String name, int initialCapacity) {
        this.name = name;
        cache = new HashMap(initialCapacity);
    }

    public String getName() {
        return name;
    }

    public V get(K key) {
        readLock.lock();
        try {
            return cache.get(key);
        } finally {
            readLock.unlock();
        }
    }

    public Mapextends K, ? extends V> getAll(Iteratorextends K> keys) {
        readLock.lock();
        try {
            Map map = new HashMap();
            List noEntryKeys = new ArrayList();
            while(keys.hasNext()) {
                K key = keys.next();
                if(isPresent(key)) {
                    map.put(key, cache.get(key));
                } else {
                    noEntryKeys.add(key);
                }
            }

            if(!noEntryKeys.isEmpty()) {
                throw new CacheEntriesNotExistException(this, noEntryKeys);
            }

            return map;
        } finally {
            readLock.unlock();
        }
    }

    public boolean isPresent(K key) {
        readLock.lock();
        try {
            return cache.containsKey(key);
        } finally {
            readLock.unlock();
        }
    }

    public void put(K key, V value) {
        writeLock.lock();
        try {
            cache.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }

    public void putAll(Mapextends K, ? extends V> entries) {
        writeLock.lock();
        try {
            cache.putAll(entries);
        } finally {
            writeLock.unlock();
        }
    }

    public void invalidate(K key) {
        writeLock.lock();
        try {
            if(!isPresent(key)) {
                throw new CacheEntryNotExistsException(this, key);
            }
            cache.remove(key);
        } finally {
            writeLock.unlock();
        }
    }

    public void invalidateAll(Iteratorextends K> keys) {
        writeLock.lock();
        try {
            List noEntryKeys = new ArrayList();
            while(keys.hasNext()) {
                K key = keys.next();
                if(!isPresent(key)) {
                    noEntryKeys.add(key);
                }
            }
            if(!noEntryKeys.isEmpty()) {
                throw new CacheEntriesNotExistException(this, noEntryKeys);
            }

            while(keys.hasNext()) {
                K key = keys.next();
                invalidate(key);
            }
        } finally {
            writeLock.unlock();
        }
    }

    public void invalidateAll() {
        writeLock.lock();
        try {
            cache.clear();
        } finally {
            writeLock.unlock();
        }
    }

    public int size() {
        readLock.lock();
        try {
            return cache.size();
        } finally {
            readLock.unlock();
        }
    }

    public void clear() {
        writeLock.lock();
        try {
            cache.clear();
        } finally {
            writeLock.unlock();
        }
    }

    public Mapextends K, ? extends V> asMap() {
        readLock.lock();
        try {
            return new ConcurrentHashMap(cache);
        } finally {
            readLock.unlock();
        }
    }

    public boolean isEmpty() {
        readLock.lock();
        try {
            return cache.isEmpty();
        } finally {
            readLock.unlock();
        }
    }

}

其简单的使用用例如下�Q?

@Test
    public void testCacheSimpleUsage() {
        Book uml = bookFactory.createUMLDistilled();
        Book derivatives = bookFactory.createDerivatives();

        String umlBookISBN = uml.getIsbn();
        String derivativesBookISBN = derivatives.getIsbn();

        Cache cache = cacheFactory.create("book-cache");
        cache.put(umlBookISBN, uml);
        cache.put(derivativesBookISBN, derivatives);

        Book fetchedBackUml = cache.get(umlBookISBN);
        System.out.println(fetchedBackUml);

        Book fetchedBackDerivatives = cache.get(derivativesBookISBN);
        System.out.println(fetchedBackDerivatives);
    }

DLevin 2013-10-15 23:46 发表评论

Map deserialize from String

DLevin — Tue, 20 Sep 2011 07:54:00 GMT

1public class MapDeserialize {
2    public static void main(String[] args) {
3        Map<String, String> map = new HashMap<String, String>();
4        map.put("key1", "value1");
5        map.put("key2", null);
6        map.put("key3", "");
7
8        System.out.println(map);
9
10        Map<String, String> emptyMap = new HashMap<String, String>();
11        System.out.println(emptyMap);
12
13        MapDeserialize deserialize = new MapDeserialize();
14        String str1 = "{key3=, key2=null, key1=value1}";
15        String str2 = "{}";
16        Map<String, String> map1 = deserialize.str2Map(str1);
17        System.out.println("map1: " + map1);
18        Map<String, String> map2 = deserialize.str2Map(str2);
19        System.out.println("map2: " + map2);
20    }
21
22    // We are assuming that the str is generated by map.toString(), so the str will be something like:
23    // '{key3=, key2=null, key1=value1}' or '{}'
24    public Map<String, String> str2Map(String str) {
25        Map<String, String> map = new HashMap<String, String>();
26        // The parameters map is empty
27        if("{}".equals(str) || str == null || str.length() == 0) {
28            return map;
29        }
30
31        // Remove the '{' prefix and '}' suffix
32        str = str.substring(1, str.length() - 1);
33        String[] entries = str.split(",");
34        for(String entry : entries) {
35            String[] pair = entry.split("=");
36            String key = pair[0].trim();
37            if(pair.length == 1) {
38                map.put(key, "");
39            } else {
40                String value = pair[1].trim();
41                if("null".equals(value)) {
42                    map.put(key, null);
43                } else {
44                    map.put(key, value);
45                }
46            }
47        }
48
49        return map;
50    }
51}

�q�段代码貌似没什么�h��|��只是保留着�Q�以后再遇到相应的情况，可以再做改进�?

DLevin 2011-09-20 15:54 发表评论

DLevin — Fri, 08 Jul 2011 03:05:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1/** *//** 2 * 在C#中提供了一个专门用于简单测试运行时间的�c�StopWatch�Q?nbsp; 3&nb... 阅读全文

DLevin 2011-07-08 11:05 发表评论