#422

Committed 27 Apr 2025 06:35AM UTC coverage: 88.775% (-0.01%) from 88.785%

Build # #422

Build Type

push

Committed by

Commit Message

fix: use JetCacheExecutor.class 's class loader as JetCacheExecutor thread's context class loader (#975)

Run Details

3 of 4 new or added lines in 1 file covered. (75.0%)

2 existing lines in 1 file now uncovered.

4753 of 5354 relevant lines covered (88.77%)

0.89 hits per line

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

85.37

/jetcache-core/src/main/java/com/alicp/jetcache/support/JetCacheExecutor.java

package com.alicp.jetcache.support;

import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created on 2017/5/3.
 *
 * @author huangli
 */
public class JetCacheExecutor {
    protected volatile static ScheduledExecutorService defaultExecutor;
    protected volatile static ScheduledExecutorService heavyIOExecutor;
    private static final ReentrantLock reentrantLock = new ReentrantLock();

    private static AtomicInteger threadCount = new AtomicInteger(0);

    static {
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                if (defaultExecutor != null) {
                    defaultExecutor.shutdownNow();
                }
                if (heavyIOExecutor != null) {
                    heavyIOExecutor.shutdownNow();
                }
            }
        });
    }

    public static ScheduledExecutorService defaultExecutor() {
        if (defaultExecutor != null) {
            return defaultExecutor;
        }
        reentrantLock.lock();
        try{
            if (defaultExecutor == null) {
                ThreadFactory tf = r -> {
                    Thread t = new Thread(r, "JetCacheDefaultExecutor");
                    t.setDaemon(true);

                    ClassLoader classLoader = JetCacheExecutor.class.getClassLoader();
                    if (classLoader == null) {
                        // This class was loaded by the Bootstrap ClassLoader,
                        // so let's tie the thread's context ClassLoader to the System ClassLoader instead.
                        classLoader = ClassLoader.getSystemClassLoader();
                    }
                    t.setContextClassLoader(classLoader);

                    return t;
                };
                int coreSize = Math.min(4, Runtime.getRuntime().availableProcessors());
                defaultExecutor = new ScheduledThreadPoolExecutor(coreSize, tf);
            }
        }finally {
            reentrantLock.unlock();
        }
        return defaultExecutor;
    }

    public static ScheduledExecutorService heavyIOExecutor() {
        if (heavyIOExecutor != null) {
            return heavyIOExecutor;
        }
        reentrantLock.lock();
        try {
            if (heavyIOExecutor == null) {
                ThreadFactory tf = r -> {
                    Thread t = new Thread(r, "JetCacheHeavyIOExecutor" + threadCount.getAndIncrement());
                    t.setDaemon(true);
                    return t;
                };
                heavyIOExecutor = new ScheduledThreadPoolExecutor(
                        10, tf, new ThreadPoolExecutor.DiscardPolicy());
            }
        }finally {
            reentrantLock.unlock();
        }
        return heavyIOExecutor;
    }

    public static void setDefaultExecutor(ScheduledExecutorService executor) {
        JetCacheExecutor.defaultExecutor = executor;
    }

    public static void setHeavyIOExecutor(ScheduledExecutorService heavyIOExecutor) {
        JetCacheExecutor.heavyIOExecutor = heavyIOExecutor;
    }
}

1	package com.alicp.jetcache.support;
2
3	import java.util.concurrent.ScheduledExecutorService;
4	import java.util.concurrent.ScheduledThreadPoolExecutor;
5	import java.util.concurrent.ThreadFactory;
6	import java.util.concurrent.ThreadPoolExecutor;
7	import java.util.concurrent.atomic.AtomicInteger;
8	import java.util.concurrent.locks.ReentrantLock;
9
10	/**
11	* Created on 2017/5/3.
12	*
13	* @author huangli
14	*/
15	public class JetCacheExecutor {	×
16	protected volatile static ScheduledExecutorService defaultExecutor;
17	protected volatile static ScheduledExecutorService heavyIOExecutor;
18	private static final ReentrantLock reentrantLock = new ReentrantLock();	1✔
19
20	private static AtomicInteger threadCount = new AtomicInteger(0);	1✔
21
22	static {
23	Runtime.getRuntime().addShutdownHook(new Thread() {	1✔
24	@Override
25	public void run() {
26	if (defaultExecutor != null) {	1✔
27	defaultExecutor.shutdownNow();	1✔
28	}
29	if (heavyIOExecutor != null) {	1✔
30	heavyIOExecutor.shutdownNow();	1✔
31	}
32	}	1✔
33	});
34	}	1✔
35
36	public static ScheduledExecutorService defaultExecutor() {
37	if (defaultExecutor != null) {	1✔
38	return defaultExecutor;	1✔
39	}
40	reentrantLock.lock();	1✔
41	try{
42	if (defaultExecutor == null) {	1✔
43	ThreadFactory tf = r -> {	1✔
44	Thread t = new Thread(r, "JetCacheDefaultExecutor");	1✔
45	t.setDaemon(true);	1✔
46
47	ClassLoader classLoader = JetCacheExecutor.class.getClassLoader();	1✔
48	if (classLoader == null) {	1✔
49	// This class was loaded by the Bootstrap ClassLoader,
50	// so let's tie the thread's context ClassLoader to the System ClassLoader instead.
NEW 51	classLoader = ClassLoader.getSystemClassLoader();	×
52	}
53	t.setContextClassLoader(classLoader);	1✔
54
55	return t;	1✔
56	};
57	int coreSize = Math.min(4, Runtime.getRuntime().availableProcessors());	1✔
58	defaultExecutor = new ScheduledThreadPoolExecutor(coreSize, tf);	1✔
59	}
60	}finally {
61	reentrantLock.unlock();	1✔
62	}
63	return defaultExecutor;	1✔
64	}
65
66	public static ScheduledExecutorService heavyIOExecutor() {
67	if (heavyIOExecutor != null) {	1✔
68	return heavyIOExecutor;	1✔
69	}
70	reentrantLock.lock();	1✔
71	try {
72	if (heavyIOExecutor == null) {	1✔
73	ThreadFactory tf = r -> {	1✔
74	Thread t = new Thread(r, "JetCacheHeavyIOExecutor" + threadCount.getAndIncrement());	1✔
75	t.setDaemon(true);	1✔
76	return t;	1✔
77	};
78	heavyIOExecutor = new ScheduledThreadPoolExecutor(	1✔
79	10, tf, new ThreadPoolExecutor.DiscardPolicy());
80	}
81	}finally {
82	reentrantLock.unlock();	1✔
83	}
84	return heavyIOExecutor;	1✔
85	}
86
87	public static void setDefaultExecutor(ScheduledExecutorService executor) {
88	JetCacheExecutor.defaultExecutor = executor;	×
89	}	×
90
91	public static void setHeavyIOExecutor(ScheduledExecutorService heavyIOExecutor) {
92	JetCacheExecutor.heavyIOExecutor = heavyIOExecutor;	×
93	}	×
94	}

alibaba / jetcache / #422

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