#405

Committed 16 Apr 2024 05:58AM UTC coverage: 0.0% (-88.9%) from 88.866%

Build # #405

Build Type

push

Committed by

Commit Message

add encoding to fix coverage report

Run Details

0 of 5353 relevant lines covered (0.0%)

0.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/jetcache-core/src/main/java/com/alicp/jetcache/embedded/LinkedHashMapCache.java

/**
 * Created on  13-09-12 19:02
 */
package com.alicp.jetcache.embedded;

import com.alicp.jetcache.CacheResultCode;
import com.alicp.jetcache.CacheValueHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author huangli
 */
public class LinkedHashMapCache<K, V> extends AbstractEmbeddedCache<K, V> {

    private static Logger logger = LoggerFactory.getLogger(LinkedHashMapCache.class);

    public LinkedHashMapCache(EmbeddedCacheConfig<K, V> config) {
        super(config);
        addToCleaner();
    }

    protected void addToCleaner() {
        Cleaner.add(this);
    }

    @Override
    protected InnerMap createAreaCache() {
        return new LRUMap(config.getLimit());
    }

    @Override
    public <T> T unwrap(Class<T> clazz) {
        if (clazz.equals(LinkedHashMap.class)) {
            return (T) innerMap;
        }
        throw new IllegalArgumentException(clazz.getName());
    }

    public void cleanExpiredEntry() {
        ((LRUMap) innerMap).cleanExpiredEntry();
    }

    final class LRUMap extends LinkedHashMap implements InnerMap {

        private final int max;
//        private final Object lockObj;
        private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

        public LRUMap(int max) {
            super((int) (max * 1.4f), 0.75f, true);
            this.max = max;
//            this.lockObj = lockObj;
        }

        @Override
        protected boolean removeEldestEntry(Map.Entry eldest) {
            return size() > max;
        }

        void cleanExpiredEntry() {
            Lock lock = readWriteLock.writeLock();
            lock.lock();
            try{
                for (Iterator it = entrySet().iterator(); it.hasNext();) {
                    Map.Entry en = (Map.Entry) it.next();
                    Object value = en.getValue();
                    if (value != null && value instanceof CacheValueHolder) {
                        CacheValueHolder h = (CacheValueHolder) value;
                        if (System.currentTimeMillis() >= h.getExpireTime()) {
                            it.remove();
                        }
                    } else {
                        // assert false
                        if (value == null) {
                            logger.error("key " + en.getKey() + " is null");
                        } else {
                            logger.error("value of key " + en.getKey() + " is not a CacheValueHolder. type=" + value.getClass());
                        }
                    }
                }
            }finally {
                lock.unlock();
            }
        }

        @Override
        public Object getValue(Object key) {
            Lock lock = readWriteLock.readLock();
            lock.lock();
            try{
                return get(key);
            }finally {
                lock.unlock();
            }
        }

        @Override
        public Map getAllValues(Collection keys) {
            Lock lock = readWriteLock.readLock();
            lock.lock();
            Map values = new HashMap();
            try{
                for (Object key : keys) {
                    Object v = get(key);
                    if (v != null) {
                        values.put(key, v);
                    }
                }
            }finally {
                lock.unlock();
            }
            return values;
        }

        @Override
        public void putValue(Object key, Object value) {
            Lock lock = readWriteLock.writeLock();
            lock.lock();
            try{
                put(key, value);
            }finally {
                lock.unlock();
            }
        }

        @Override
        public void putAllValues(Map map) {
            Lock lock = readWriteLock.writeLock();
            lock.lock();
            try{
                Set<Map.Entry> set = map.entrySet();
                for (Map.Entry en : set) {
                    put(en.getKey(), en.getValue());
                }
            }finally {
                lock.unlock();
            }
        }

        @Override
        public boolean removeValue(Object key) {
            Lock lock = readWriteLock.writeLock();
            lock.lock();
            try{
                return remove(key) != null;
            }finally {
                lock.unlock();
            }
        }

        @Override
        public void removeAllValues(Collection keys) {
            Lock lock = readWriteLock.writeLock();
            lock.lock();
            try{
                for (Object k : keys) {
                    remove(k);
                }
            }finally {
                lock.unlock();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public boolean putIfAbsentValue(Object key, Object value) {
            Lock lock = readWriteLock.writeLock();
            lock.lock();
            try{
                CacheValueHolder h = (CacheValueHolder) get(key);
                if (h == null || parseHolderResult(h).getResultCode() == CacheResultCode.EXPIRED) {
                    put(key, value);
                    return true;
                } else {
                    return false;
                }
            }finally {
                lock.unlock();
            }
        }
    }


}


1	/**
2	* Created on 13-09-12 19:02
3	*/
4	package com.alicp.jetcache.embedded;
5
6	import com.alicp.jetcache.CacheResultCode;
7	import com.alicp.jetcache.CacheValueHolder;
8	import org.slf4j.Logger;
9	import org.slf4j.LoggerFactory;
10
11	import java.util.*;
12	import java.util.concurrent.locks.Lock;
13	import java.util.concurrent.locks.ReentrantReadWriteLock;
14
15	/**
16	* @author huangli
17	*/
18	public class LinkedHashMapCache<K, V> extends AbstractEmbeddedCache<K, V> {
19
20	private static Logger logger = LoggerFactory.getLogger(LinkedHashMapCache.class);	×
21
22	public LinkedHashMapCache(EmbeddedCacheConfig<K, V> config) {
23	super(config);	×
24	addToCleaner();	×
25	}	×
26
27	protected void addToCleaner() {
28	Cleaner.add(this);	×
29	}	×
30
31	@Override
32	protected InnerMap createAreaCache() {
33	return new LRUMap(config.getLimit());	×
34	}
35
36	@Override
37	public <T> T unwrap(Class<T> clazz) {
38	if (clazz.equals(LinkedHashMap.class)) {	×
39	return (T) innerMap;	×
40	}
41	throw new IllegalArgumentException(clazz.getName());	×
42	}
43
44	public void cleanExpiredEntry() {
45	((LRUMap) innerMap).cleanExpiredEntry();	×
46	}	×
47
48	final class LRUMap extends LinkedHashMap implements InnerMap {
49
50	private final int max;
51	// private final Object lockObj;
52	private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();	×
53
54	public LRUMap(int max) {	×
55	super((int) (max * 1.4f), 0.75f, true);	×
56	this.max = max;	×
57	// this.lockObj = lockObj;
58	}	×
59
60	@Override
61	protected boolean removeEldestEntry(Map.Entry eldest) {
62	return size() > max;	×
63	}
64
65	void cleanExpiredEntry() {
66	Lock lock = readWriteLock.writeLock();	×
67	lock.lock();	×
68	try{
69	for (Iterator it = entrySet().iterator(); it.hasNext();) {	×
70	Map.Entry en = (Map.Entry) it.next();	×
71	Object value = en.getValue();	×
72	if (value != null && value instanceof CacheValueHolder) {	×
73	CacheValueHolder h = (CacheValueHolder) value;	×
74	if (System.currentTimeMillis() >= h.getExpireTime()) {	×
75	it.remove();	×
76	}
77	} else {	×
78	// assert false
79	if (value == null) {	×
80	logger.error("key " + en.getKey() + " is null");	×
81	} else {
82	logger.error("value of key " + en.getKey() + " is not a CacheValueHolder. type=" + value.getClass());	×
83	}
84	}
85	}	×
86	}finally {
87	lock.unlock();	×
88	}
89	}	×
90
91	@Override
92	public Object getValue(Object key) {
93	Lock lock = readWriteLock.readLock();	×
94	lock.lock();	×
95	try{
96	return get(key);	×
97	}finally {
98	lock.unlock();	×
99	}
100	}
101
102	@Override
103	public Map getAllValues(Collection keys) {
104	Lock lock = readWriteLock.readLock();	×
105	lock.lock();	×
106	Map values = new HashMap();	×
107	try{
108	for (Object key : keys) {	×
109	Object v = get(key);	×
110	if (v != null) {	×
111	values.put(key, v);	×
112	}
113	}	×
114	}finally {
115	lock.unlock();	×
116	}
117	return values;	×
118	}
119
120	@Override
121	public void putValue(Object key, Object value) {
122	Lock lock = readWriteLock.writeLock();	×
123	lock.lock();	×
124	try{
125	put(key, value);	×
126	}finally {
127	lock.unlock();	×
128	}
129	}	×
130
131	@Override
132	public void putAllValues(Map map) {
133	Lock lock = readWriteLock.writeLock();	×
134	lock.lock();	×
135	try{
136	Set<Map.Entry> set = map.entrySet();	×
137	for (Map.Entry en : set) {	×
138	put(en.getKey(), en.getValue());	×
139	}	×
140	}finally {
141	lock.unlock();	×
142	}
143	}	×
144
145	@Override
146	public boolean removeValue(Object key) {
147	Lock lock = readWriteLock.writeLock();	×
148	lock.lock();	×
149	try{
150	return remove(key) != null;	×
151	}finally {
152	lock.unlock();	×
153	}
154	}
155
156	@Override
157	public void removeAllValues(Collection keys) {
158	Lock lock = readWriteLock.writeLock();	×
159	lock.lock();	×
160	try{
161	for (Object k : keys) {	×
162	remove(k);	×
163	}	×
164	}finally {
165	lock.unlock();	×
166	}
167	}	×
168
169	@Override
170	@SuppressWarnings("unchecked")
171	public boolean putIfAbsentValue(Object key, Object value) {
172	Lock lock = readWriteLock.writeLock();	×
173	lock.lock();	×
174	try{
175	CacheValueHolder h = (CacheValueHolder) get(key);	×
176	if (h == null \|\| parseHolderResult(h).getResultCode() == CacheResultCode.EXPIRED) {	×
177	put(key, value);	×
178	return true;	×
179	} else {
180	return false;	×
181	}
182	}finally {
183	lock.unlock();	×
184	}
185	}
186	}
187
188
189	}
190

alibaba / jetcache / #405

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous