#423

Committed 27 Apr 2025 06:38AM UTC coverage: 88.82% (+0.05%) from 88.775%

Build # #423

Build Type

push

Committed by

Commit Message

fix: use classloader of jetcache as heavyIOExecutor thread context classloader

Run Details

4 of 5 new or added lines in 1 file covered. (80.0%)

4759 of 5358 relevant lines covered (88.82%)

0.89 hits per line

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

84.44

/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 final 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);
                    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;
                };
                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 final 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.
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	ClassLoader classLoader = JetCacheExecutor.class.getClassLoader();	1✔
77	if (classLoader == null) {	1✔
78	// This class was loaded by the Bootstrap ClassLoader,
79	// so let's tie the thread's context ClassLoader to the System ClassLoader instead.
NEW 80	classLoader = ClassLoader.getSystemClassLoader();	×
81	}
82	t.setContextClassLoader(classLoader);	1✔
83	return t;	1✔
84	};
85	heavyIOExecutor = new ScheduledThreadPoolExecutor(	1✔
86	10, tf, new ThreadPoolExecutor.DiscardPolicy());
87	}
88	}finally {
89	reentrantLock.unlock();	1✔
90	}
91	return heavyIOExecutor;	1✔
92	}
93
94	public static void setDefaultExecutor(ScheduledExecutorService executor) {
95	JetCacheExecutor.defaultExecutor = executor;	×
96	}	×
97
98	public static void setHeavyIOExecutor(ScheduledExecutorService heavyIOExecutor) {
99	JetCacheExecutor.heavyIOExecutor = heavyIOExecutor;	×
100	}	×
101	}

alibaba / jetcache / #423

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