diff --git a/checkstyle/checkstyle-suppressions.xml b/checkstyle/checkstyle-suppressions.xml
index 9211327b53b4c..a45d4f12af9b0 100644
--- a/checkstyle/checkstyle-suppressions.xml
+++ b/checkstyle/checkstyle-suppressions.xml
@@ -23,7 +23,49 @@
 <suppressions>
     <suppress checks="RightCurly|LeftCurly|EmptyLineSeparator|MethodParamPad|SingleSpaceSeparator"
               files="BCrypt\.java|ConcurrentLinkedDeque8\.java"/>
-    <suppress checks="NoWhitespaceBefore" files="ConcurrentLinkedHashMap\.java"/>
+
+    <suppress checks="NoWhitespaceBefore"
+              files="ConcurrentLinkedHashMap\.java"/>
+
     <suppress checks="LineLength"
               files="ClusterTagGenerator\.java|PagesWriteSpeedBasedThrottle\.java|GridExecutorService\.java|CatboostClassificationModel\.java|classnames\.properties"/>
+
+    <suppress checks="(?&lt;!Missing)JavadocMethod"
+              files="[\\/]internal[\\/]"/>
+
+    <suppress checks="(?&lt;!Missing)JavadocMethod"
+              files="[\\/]test[\\/]"/>
+
+    <suppress checks="(?&lt;!Missing)JavadocMethod"
+              files="[\\/]tests[\\/]"/>
+
+    <suppress checks="(?&lt;!Missing)JavadocMethod"
+              files="[\\/]ml[\\/]"/>
+
+    <suppress checks="(?&lt;!Missing)JavadocMethod"
+              files="[\\/]yardstick[\\/]"/>
+
+    <suppress checks="Javadoc"
+              files="BCrypt\.java|HLL\.java|HLLMetadata\.java|HLLType\.java|BigEndianAscendingWordSerializer\.java|NumberUtil\.java|SchemaVersionOne\.java|BigEndianAscendingWordDeserializer\.java|CacheView\.java|ConcurrentLinkedDeque8\.java|ConcurrentHashMap8\.java|ConcurrentLinkedHashMap\.java"/>
+
+    <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
+              files="[\\/]yardstick[\\/]"/>
+
+    <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
+              files="[\\/]internal[\\/]thread[\\/]"/>
+
+    <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
+              files="[\\/]internal[\\/]jdbc[\\/]thin[\\/]"/>
+
+    <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
+              files="[\\/]internal[\\/]client[\\/]"/>
+
+    <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
+              files="[\\/]io[\\/]opencensus[\\/]"/>
+
+    <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
+              files="[\\/]test[\\/]|[\\/]tests[\\/]"/>
+
+    <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
+              files="DumpReader\.java|CacheLoadOnlyStoreAdapter\.java"/>
 </suppressions>
diff --git a/checkstyle/checkstyle-xpath-suppressions.xml b/checkstyle/checkstyle-xpath-suppressions.xml
new file mode 100644
index 0000000000000..2ab024fbe908b
--- /dev/null
+++ b/checkstyle/checkstyle-xpath-suppressions.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0"?>
+
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<!DOCTYPE suppressions PUBLIC
+    "-//Checkstyle//DTD SuppressionXpathFilter Experimental Configuration 1.2//EN"
+    "https://checkstyle.org/dtds/suppressions_1_2_xpath_experimental.dtd">
+<suppressions>
+    <suppress-xpath checks="AnnotationOnSameLine"
+                    query="//ANNOTATION[.//IDENT[not(@text='Override')]]"/>
+</suppressions>
diff --git a/checkstyle/checkstyle.xml b/checkstyle/checkstyle.xml
index c688bcf1b3e86..dec1a2958b78f 100644
--- a/checkstyle/checkstyle.xml
+++ b/checkstyle/checkstyle.xml
@@ -24,6 +24,11 @@
 
     <property name="fileExtensions" value="java, properties, xml"/>
 
+    <!-- Suppressions. See: https://checkstyle.sourceforge.io/filters/suppressionfilter.html -->
+    <module name="SuppressionFilter">
+        <property name="file" value="checkstyle/checkstyle-suppressions.xml"/>
+    </module>
+
     <!-- Whitespaces Checks. See: http://checkstyle.sourceforge.net/config_whitespace.html -->
     <module name="FileTabCharacter">
         <property name="eachLine" value="true"/>
@@ -39,6 +44,11 @@
     </module>
 
     <module name="TreeWalker">
+        <!-- Suppressions. See: https://checkstyle.sourceforge.io/filters/suppressionxpathfilter.html -->
+        <module name="SuppressionXpathFilter">
+            <property name="file" value="checkstyle/checkstyle-xpath-suppressions.xml"/>
+        </module>
+
         <!-- Coding Checks. See: https://checkstyle.sourceforge.io/config_coding.html -->
         <module name="SimplifyBooleanExpression"/>
 
@@ -88,10 +98,7 @@
 
         <!-- @Override annotations on the same line with a method declaration check. -->
         <module name="AnnotationOnSameLine" />
-        <module name="SuppressionXpathSingleFilter">
-            <property name="checks" value="AnnotationOnSameLine" />
-            <property name="query" value="//ANNOTATION[.//IDENT[not(@text='Override')]]" />
-        </module>
+
         <!--
             Checks the padding between the identifier of a method definition, constructor definition, method call, or
             constructor invocation; and the left parenthesis of the parameter list.
@@ -172,24 +179,6 @@
         -->
         <module name="JavadocVariable"/>
 
-        <!--
-          Suppresses MissingJavadocMethod check violations in the specified packages.
-          See: https://checkstyle.sourceforge.io/config_filters.html#SuppressionXpathSingleFilter
-       -->
-        <module name="SuppressionXpathSingleFilter">
-            <property name="checks" value="(?&lt;!Missing)JavadocMethod"/>
-            <property name="files" value="[\\/]internal[\\/]|[\\/]test[\\/]|[\\/]tests[\\/]|[\\/]ml[\\/]|[\\/]yardstick[\\/]"/>
-        </module>
-
-        <!--
-          Suppresses all Javadoc check violations in the specified files.
-          See: https://checkstyle.sourceforge.io/config_filters.html#SuppressionXpathSingleFilter
-       -->
-        <module name="SuppressionXpathSingleFilter">
-            <property name="checks" value="Javadoc"/>
-            <property name="files" value="BCrypt\.java|HLL\.java|HLLMetadata\.java|HLLType\.java|BigEndianAscendingWordSerializer\.java|NumberUtil\.java|SchemaVersionOne\.java|BigEndianAscendingWordDeserializer\.java|CacheView\.java|ConcurrentLinkedDeque8\.java|ConcurrentHashMap8\.java|ConcurrentLinkedHashMap\.java"/>
-        </module>
-
         <module name="Indentation" />
 
         <module name="LeftCurly"/>
@@ -200,6 +189,35 @@
 
         <!-- Usage of Ignite abbrevations check. -->
         <module name="org.apache.ignite.tools.checkstyle.IgniteAbbrevationsRule"/>
+
+        <!-- Prevents usage of the particular Java classes in Ignite codebase. -->
+        <module name="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule">
+            <property name="className" value="java.util.concurrent.ForkJoinPool"/>
+            <property name="factoryMethods" value="commonPool"/>
+            <property name="substitutionClassName" value="org.apache.ignite.internal.thread.pool.IgniteForkJoinPool"/>
+        </module>
+
+        <module name="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule">
+            <property name="className" value="java.util.concurrent.Executors"/>
+            <property name="factoryMethods" value="newFixedThreadPool, newWorkStealingPool, newSingleThreadExecutor, newCachedThreadPool, unconfigurableExecutorService"/>
+            <property name="substitutionClassName" value="org.apache.ignite.internal.thread.IgniteThreadPoolExecutor"/>
+        </module>
+
+        <module name="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule">
+            <property name="className" value="java.util.concurrent.Executors"/>
+            <property name="factoryMethods" value="newSingleThreadScheduledExecutor, newScheduledThreadPool, unconfigurableScheduledExecutorService"/>
+            <property name="substitutionClassName" value="org.apache.ignite.internal.thread.pool.IgniteScheduledThreadPoolExecutor"/>
+        </module>
+
+        <module name="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule">
+            <property name="className" value="java.util.concurrent.ThreadPoolExecutor"/>
+            <property name="substitutionClassName" value="org.apache.ignite.internal.thread.IgniteThreadPoolExecutor"/>
+        </module>
+
+        <module name="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule">
+            <property name="className" value="java.util.concurrent.ScheduledThreadPoolExecutor"/>
+            <property name="substitutionClassName" value="org.apache.ignite.internal.thread.pool.IgniteScheduledThreadPoolExecutor"/>
+        </module>
     </module>
 
     <!--
diff --git a/modules/checkstyle/pom.xml b/modules/checkstyle/pom.xml
index 860e62145127d..e9df508336c7e 100644
--- a/modules/checkstyle/pom.xml
+++ b/modules/checkstyle/pom.xml
@@ -72,6 +72,14 @@
             <version>${checkstyle.puppycrawl.version}</version>
         </dependency>
 
+        <dependency>
+            <groupId>com.puppycrawl.tools</groupId>
+            <artifactId>checkstyle</artifactId>
+            <version>${checkstyle.puppycrawl.version}</version>
+            <type>test-jar</type>
+            <scope>test</scope>
+        </dependency>
+
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
diff --git a/modules/checkstyle/src/main/java/org/apache/ignite/tools/checkstyle/ClassUsageRestrictionRule.java b/modules/checkstyle/src/main/java/org/apache/ignite/tools/checkstyle/ClassUsageRestrictionRule.java
new file mode 100644
index 0000000000000..5b61822e6c6b0
--- /dev/null
+++ b/modules/checkstyle/src/main/java/org/apache/ignite/tools/checkstyle/ClassUsageRestrictionRule.java
@@ -0,0 +1,268 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
+import com.puppycrawl.tools.checkstyle.api.DetailAST;
+
+import static com.puppycrawl.tools.checkstyle.api.FullIdent.createFullIdent;
+import static com.puppycrawl.tools.checkstyle.api.TokenTypes.EXTENDS_CLAUSE;
+import static com.puppycrawl.tools.checkstyle.api.TokenTypes.IMPORT;
+import static com.puppycrawl.tools.checkstyle.api.TokenTypes.LITERAL_NEW;
+import static com.puppycrawl.tools.checkstyle.api.TokenTypes.METHOD_CALL;
+import static com.puppycrawl.tools.checkstyle.api.TokenTypes.METHOD_REF;
+import static com.puppycrawl.tools.checkstyle.api.TokenTypes.STATIC_IMPORT;
+
+/**
+ * Represents a rule for Static Code Analyzer that provides the ability to restrict usage of a specified Java class.
+ * The rule prevents the class from being instantiated and considers the following scenarios:
+ * <ul>
+ *    <li>extending the restricted class</li>
+ *    <li>invoking the restricted class's constructor or its new method reference</li>
+ *    <li>invoking factory methods or their references that produce instances of the restricted class</li>
+ * </ul>
+ */
+public class ClassUsageRestrictionRule extends AbstractCheck {
+    /** */
+    private static final int[] TOKENS = new int[] {
+        IMPORT,
+        STATIC_IMPORT,
+        EXTENDS_CLAUSE,
+        LITERAL_NEW,
+        METHOD_REF,
+        METHOD_CALL
+    };
+
+    /** */
+    private static final Set<String> DEFAULT_RESTRICTED_FACTORY_METHODS = Set.of("new");
+
+    /** */
+    private ClassDescriptor restrictedCls;
+
+    /** */
+    private Set<String> restrictedFactoryMethods = DEFAULT_RESTRICTED_FACTORY_METHODS;
+
+    /** */
+    private String substitutionClsName;
+
+    /** */
+    private boolean isRestrictedClsImportDetected;
+
+    /** */
+    private final Set<String> detectedMethodImports = new HashSet<>();
+
+    /** {@inheritDoc} */
+    @Override public void init() {
+        if (restrictedCls == null)
+            throw new IllegalStateException("Restricted class is not set");
+
+        if (isEmpty(substitutionClsName))
+            throw new IllegalStateException("Substitution class is not set");
+
+        if (isEmpty(restrictedCls.packageName) || isEmpty(restrictedCls.simpleName))
+            throw new IllegalStateException("Invalid restricted class name. Class FQN is required");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void beginTree(DetailAST rootAST) {
+        isRestrictedClsImportDetected = "java.lang".equals(restrictedCls.packageName);
+
+        detectedMethodImports.clear();
+    }
+
+    /** {@inheritDoc} */
+    @Override public void visitToken(DetailAST token) {
+        if (token.getType() == IMPORT) {
+            ClassDescriptor clsDesc = ClassDescriptor.forToken(token.getFirstChild());
+
+            if (isRestrictedClass(clsDesc))
+                isRestrictedClsImportDetected = true;
+        }
+        else if (token.getType() == STATIC_IMPORT) {
+            ClassMemberDescriptor memberDesc = ClassMemberDescriptor.fromToken(token.getFirstChild().getNextSibling());
+
+            if (isRestrictedMethod(memberDesc))
+                detectedMethodImports.add(memberDesc.memberName);
+        }
+        else if (token.getType() == EXTENDS_CLAUSE || token.getType() == LITERAL_NEW) {
+            ClassDescriptor clsDesc = ClassDescriptor.forToken(token.getFirstChild());
+
+            if (isRestrictedClass(clsDesc))
+                logFailure(token);
+        }
+        else if (token.getType() == METHOD_REF) {
+            ClassMemberDescriptor methodDesc = ClassMemberDescriptor.fromMethodReferenceToken(token);
+
+            if (isRestrictedMethod(methodDesc))
+                logFailure(token);
+        }
+        else if (token.getType() == METHOD_CALL) {
+            ClassMemberDescriptor methodDesc = ClassMemberDescriptor.fromToken(token.getFirstChild());
+
+            if (isRestrictedMethod(methodDesc))
+                logFailure(token);
+        }
+        else
+            throw new IllegalStateException();
+    }
+
+    /** {@inheritDoc} */
+    @Override public int[] getDefaultTokens() {
+        return TOKENS.clone();
+    }
+
+    /** {@inheritDoc} */
+    @Override public int[] getAcceptableTokens() {
+        return TOKENS.clone();
+    }
+
+    /** {@inheritDoc} */
+    @Override public int[] getRequiredTokens() {
+        return TOKENS.clone();
+    }
+
+    /** @param clsName The fully qualified name of the Java class which use should be restricted. */
+    public void setClassName(String clsName) {
+        restrictedCls = ClassDescriptor.forName(clsName);
+    }
+
+    /** @param factoryMethods A comma-separated list of restricted class factory method names that should be prevented from being called. */
+    public void setFactoryMethods(String factoryMethods) {
+        Set<String> restrictedFactoryMethods = new HashSet<>(DEFAULT_RESTRICTED_FACTORY_METHODS);
+
+        Arrays.stream(factoryMethods.split(",")).map(String::trim).forEach(restrictedFactoryMethods::add);
+
+        this.restrictedFactoryMethods = restrictedFactoryMethods;
+    }
+
+    /**
+     * @param substitutionClsName The name of the Java class that acts as a replacement for the restricted class and is
+     * displayed in the rule violation error message.
+     */
+    public void setSubstitutionClassName(String substitutionClsName) {
+        this.substitutionClsName = substitutionClsName;
+    }
+
+    /** */
+    private void logFailure(DetailAST token) {
+        log(
+            token,
+            "Usage of {0} class and its factory methods is restricted. Use {1} class as a substitution",
+            restrictedCls.fullName,
+            substitutionClsName
+        );
+    }
+
+    /** */
+    private static boolean isEmpty(String str) {
+        return str == null || str.isEmpty();
+    }
+
+    /** */
+    private boolean isRestrictedMethod(ClassMemberDescriptor desc) {
+        if (desc.clsDesc == null)
+            return detectedMethodImports.contains(desc.memberName);
+
+        return restrictedFactoryMethods.contains(desc.memberName) && isRestrictedClass(desc.clsDesc);
+    }
+
+    /** */
+    private boolean isRestrictedClass(ClassDescriptor desc) {
+        if (Objects.equals(restrictedCls.fullName, desc.fullName))
+            return true;
+
+        return Objects.equals(restrictedCls.simpleName, desc.simpleName) && isRestrictedClsImportDetected;
+    }
+
+    /** */
+    private static class ClassDescriptor {
+        /** */
+        private final String fullName;
+
+        /** */
+        private final String packageName;
+
+        /** */
+        private final String simpleName;
+
+        /** */
+        public ClassDescriptor(String fullName, String packageName, String simpleName) {
+            this.fullName = fullName;
+            this.packageName = packageName;
+            this.simpleName = simpleName;
+        }
+
+        /** */
+        public static ClassDescriptor forToken(DetailAST token) {
+            return forName(createFullIdent(token).getText());
+        }
+
+        /** */
+        public static ClassDescriptor forName(String name) {
+            int sepPos = name.lastIndexOf('.');
+
+            if (sepPos == -1)
+                return new ClassDescriptor(name, "", name);
+
+            return new ClassDescriptor(name, name.substring(0, sepPos), name.substring(sepPos + 1));
+        }
+    }
+
+    /** */
+    private static class ClassMemberDescriptor {
+        /** */
+        private final ClassDescriptor clsDesc;
+
+        /** */
+        private final String memberName;
+
+        /** */
+        private ClassMemberDescriptor(ClassDescriptor clsDesc, String memberName) {
+            this.clsDesc = clsDesc;
+            this.memberName = memberName;
+        }
+
+        /** */
+        public static ClassMemberDescriptor fromMethodReferenceToken(DetailAST token) {
+            DetailAST clsToken = token.getFirstChild();
+
+            DetailAST methodToken = clsToken.getNextSibling();
+
+            return new ClassMemberDescriptor(ClassDescriptor.forToken(clsToken), methodToken.getText());
+        }
+
+        /** */
+        public static ClassMemberDescriptor fromToken(DetailAST token) {
+            final String tokenText = createFullIdent(token).getText();
+
+            final int memberSepPos = tokenText.lastIndexOf('.');
+
+            if (memberSepPos == -1)
+                return new ClassMemberDescriptor(null, tokenText);
+
+            return new ClassMemberDescriptor(
+                ClassDescriptor.forName(tokenText.substring(0, memberSepPos)),
+                tokenText.substring(memberSepPos + 1)
+            );
+        }
+    }
+}
diff --git a/modules/checkstyle/src/test/java/org/apache/ignite/tools/checkstyle/ClassUsageRestrictionRuleTest.java b/modules/checkstyle/src/test/java/org/apache/ignite/tools/checkstyle/ClassUsageRestrictionRuleTest.java
new file mode 100644
index 0000000000000..e9662616b2090
--- /dev/null
+++ b/modules/checkstyle/src/test/java/org/apache/ignite/tools/checkstyle/ClassUsageRestrictionRuleTest.java
@@ -0,0 +1,251 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+import java.io.File;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import com.puppycrawl.tools.checkstyle.Checker;
+import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
+import com.puppycrawl.tools.checkstyle.api.AuditEvent;
+import com.puppycrawl.tools.checkstyle.api.AuditListener;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/** */
+public class ClassUsageRestrictionRuleTest {
+    /** */
+    private static final String RESTRICTED_CLASS = "java.util.concurrent.ForkJoinPool";
+
+    /** */
+    private static final String[] RESTRICTED_FACTORY_METHODS = new String[] {
+        "commonPool"
+    };
+
+    /** */
+    private static final String SUBSTITUTION_CLASS = "org.apache.ignite.AllowedClass";
+
+    /** */
+    @Test
+    public void testExtends() throws Exception {
+        assertCheckstyleFailure("RestrictedExtends.java", RESTRICTED_CLASS);
+    }
+
+    /** */
+    @Test
+    public void testExtendsFullName() throws Exception {
+        assertCheckstyleFailure("RestrictedExtendsFullName.java", RESTRICTED_CLASS);
+    }
+
+    /** */
+    @Test
+    public void testFactoryMethod() throws Exception {
+        assertCheckstyleFailure("RestrictedFactoryMethod.java", RESTRICTED_CLASS, RESTRICTED_FACTORY_METHODS);
+    }
+
+    /** */
+    @Test
+    public void testFactoryMethodFullName() throws Exception {
+        assertCheckstyleFailure("RestrictedFactoryMethodFullName.java", RESTRICTED_CLASS, RESTRICTED_FACTORY_METHODS);
+    }
+
+    /** */
+    @Test
+    public void testFactoryMethodStaticImport() throws Exception {
+        assertCheckstyleFailure("RestrictedFactoryMethodStaticImport.java", RESTRICTED_CLASS, RESTRICTED_FACTORY_METHODS);
+    }
+
+    /** */
+    @Test
+    public void testFactoryMethodReference() throws Exception {
+        assertCheckstyleFailure("RestrictedFactoryMethodReference.java", RESTRICTED_CLASS, RESTRICTED_FACTORY_METHODS);
+    }
+
+    /** */
+    @Test
+    public void testFactoryMethodReferenceFullName() throws Exception {
+        assertCheckstyleFailure("RestrictedFactoryMethodReferenceFullName.java", RESTRICTED_CLASS, RESTRICTED_FACTORY_METHODS);
+    }
+
+    /** */
+    @Test
+    public void testJavaLangClass() throws Exception {
+        assertCheckstyleFailure("RestrictedJavaLangClass.java", "java.lang.Thread");
+    }
+
+    /** */
+    @Test
+    public void testNew() throws Exception {
+        assertCheckstyleFailure("RestrictedNew.java", RESTRICTED_CLASS);
+    }
+
+    /** */
+    @Test
+    public void testNewFullName() throws Exception {
+        assertCheckstyleFailure("RestrictedNewFullName.java", RESTRICTED_CLASS);
+    }
+
+    /** */
+    @Test
+    public void testNewReference() throws Exception {
+        assertCheckstyleFailure("RestrictedNewReference.java", RESTRICTED_CLASS);
+    }
+
+    /** */
+    @Test
+    public void testNewReferenceFullName() throws Exception {
+        assertCheckstyleFailure("RestrictedNewReferenceFullName.java", RESTRICTED_CLASS);
+    }
+
+    /** */
+    @Test
+    public void testMultipleViolations() throws Exception {
+        List<AuditEvent> violations = executeCheckstyleRule("MultipleRestrictedClassUsageRuleViolations.java", RESTRICTED_CLASS, RESTRICTED_FACTORY_METHODS);
+
+        assertEquals(5, violations.size());
+
+    }
+
+    /** */
+    @Test(expected = IllegalStateException.class)
+    public void testInitFailsWithoutClassName() {
+        ClassUsageRestrictionRule rule = new ClassUsageRestrictionRule();
+
+        rule.setSubstitutionClassName("SomeClass");
+
+        rule.init();
+    }
+
+    /** */
+    @Test(expected = IllegalStateException.class)
+    public void testInitFailsWithoutSubstitutionClassName() {
+        ClassUsageRestrictionRule rule = new ClassUsageRestrictionRule();
+
+        rule.setClassName(RESTRICTED_CLASS);
+
+        rule.init();
+    }
+
+    /** */
+    @Test(expected = IllegalStateException.class)
+    public void testInitFailsWithSimpleClassName() {
+        ClassUsageRestrictionRule rule = new ClassUsageRestrictionRule();
+
+        rule.setClassName("ForkJoinPool");
+        rule.setSubstitutionClassName("SomeClass");
+
+        rule.init();
+    }
+
+    /** */
+    private void assertCheckstyleFailure(String inputFileName, String className, String... factoryMethods) throws Exception {
+        List<AuditEvent> violations = executeCheckstyleRule(inputFileName, className, factoryMethods);
+
+        assertEquals(1, violations.size());
+
+        assertEquals(
+            "Usage of " + className + " class and its factory methods is restricted." +
+                " Use " + SUBSTITUTION_CLASS + " class as a substitution",
+            violations.get(0).getMessage());
+    }
+
+    /** */
+    private List<AuditEvent> executeCheckstyleRule(
+        String inputFileName,
+        String restrictedClassName,
+        String... factoryMethods
+    ) throws Exception {
+        Checker checker = new Checker();
+
+        try {
+            checker.setModuleClassLoader(Thread.currentThread().getContextClassLoader());
+            checker.configure(checkerConfiguration(restrictedClassName, factoryMethods));
+
+            List<AuditEvent> violations = new ArrayList<>();
+
+            checker.addListener(new AuditListener() {
+                @Override public void auditStarted(AuditEvent evt) {
+                }
+
+                @Override public void auditFinished(AuditEvent evt) {
+                }
+
+                @Override public void fileStarted(AuditEvent evt) {
+                }
+
+                @Override public void fileFinished(AuditEvent evt) {
+                }
+
+                @Override public void addError(AuditEvent evt) {
+                    violations.add(evt);
+                }
+
+                @Override public void addException(AuditEvent evt, Throwable throwable) {
+                }
+            });
+
+            URL inputFile = getClass().getResource(inputFileName);
+
+            assertNotNull(inputFile);
+
+            checker.process(Collections.singletonList(new File(inputFile.toURI())));
+
+            return violations;
+        }
+        finally {
+            checker.destroy();
+        }
+    }
+
+    /** */
+    private DefaultConfiguration customCheckStyleRuleConfiguration(String restrictedClassName , String... restrictedFactoryMethods) {
+        DefaultConfiguration cfg = new DefaultConfiguration(ClassUsageRestrictionRule.class.getName());
+
+        cfg.addProperty("className", restrictedClassName);
+        cfg.addProperty("substitutionClassName", SUBSTITUTION_CLASS);
+
+        if (restrictedFactoryMethods.length != 0)
+            cfg.addProperty("factoryMethods", String.join(", ", restrictedFactoryMethods));
+
+        return cfg;
+    }
+
+    /** */
+    private DefaultConfiguration treeWalkerConfiguration(String restrictedClassName , String... restrictedFactoryMethods) {
+        DefaultConfiguration cfg = new DefaultConfiguration("TreeWalker");
+
+        cfg.addChild(customCheckStyleRuleConfiguration(restrictedClassName, restrictedFactoryMethods));
+
+        return cfg;
+    }
+
+    /** */
+    private DefaultConfiguration checkerConfiguration(String restrictedClassName , String... restrictedFactoryMethods) {
+        DefaultConfiguration cfg = new DefaultConfiguration("Checker");
+
+        cfg.addProperty("charset", "UTF-8");
+
+        cfg.addChild(treeWalkerConfiguration(restrictedClassName, restrictedFactoryMethods));
+
+        return cfg;
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/OperationContextAwareStripedThreadPoolExecutor.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/MultipleRestrictedClassUsageRuleViolations.java
similarity index 50%
rename from modules/core/src/main/java/org/apache/ignite/internal/thread/pool/OperationContextAwareStripedThreadPoolExecutor.java
rename to modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/MultipleRestrictedClassUsageRuleViolations.java
index cf9e3136cb595..86f2352c92d8f 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/OperationContextAwareStripedThreadPoolExecutor.java
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/MultipleRestrictedClassUsageRuleViolations.java
@@ -15,26 +15,23 @@
  * limitations under the License.
  */
 
-package org.apache.ignite.internal.thread.pool;
+package org.apache.ignite.tools.checkstyle;
 
-import org.apache.ignite.internal.thread.context.function.OperationContextAwareRunnable;
+import java.util.concurrent.ForkJoinPool;
+import java.util.function.Supplier;
+
+import static java.util.concurrent.ForkJoinPool.commonPool;
 
 /** */
-public class OperationContextAwareStripedThreadPoolExecutor extends IgniteStripedThreadPoolExecutor {
+public class MultipleRestrictedClassUsageRuleViolations {
     /** */
-    public OperationContextAwareStripedThreadPoolExecutor(
-        int concurrentLvl,
-        String igniteInstanceName,
-        String threadNamePrefix,
-        Thread.UncaughtExceptionHandler eHnd,
-        boolean allowCoreThreadTimeOut,
-        long keepAliveTime
-    ) {
-        super(concurrentLvl, igniteInstanceName, threadNamePrefix, eHnd, allowCoreThreadTimeOut, keepAliveTime);
-    }
+    public Runnable var0 =  () -> new ForkJoinPool();
+
+    void method() {
+        Object var1 = new ForkJoinPool();
 
-    /** {@inheritDoc} */
-    @Override public void execute(Runnable task, int idx) {
-        super.execute(OperationContextAwareRunnable.wrapIfContextNotEmpty(task), idx);
+        Supplier<ForkJoinPool> var2 = ForkJoinPool::new;
+        Supplier<ForkJoinPool> var3 = ForkJoinPool::commonPool;
+        Object var4 = commonPool();
     }
 }
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedExtends.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedExtends.java
new file mode 100644
index 0000000000000..a62aedaafc469
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedExtends.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+import java.util.concurrent.ForkJoinPool;
+
+/** */
+public class RestrictedExtends extends ForkJoinPool {
+    // No-op.
+}
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedExtendsFullName.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedExtendsFullName.java
new file mode 100644
index 0000000000000..3ce457b049966
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedExtendsFullName.java
@@ -0,0 +1,23 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+/** */
+public class RestrictedExtendsFullName extends java.util.concurrent.ForkJoinPool {
+    // No-op.
+}
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethod.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethod.java
new file mode 100644
index 0000000000000..4c62cb6a21810
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethod.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+import java.util.concurrent.ForkJoinPool;
+
+/** */
+public class RestrictedFactoryMethod {
+    /** */
+    void method() {
+        Object pool = ForkJoinPool.commonPool();
+    }
+}
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodFullName.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodFullName.java
new file mode 100644
index 0000000000000..9701f9a14c2b7
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodFullName.java
@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+/** */
+public class RestrictedFactoryMethodFullName {
+    /** */
+    void method() {
+        Object pool = java.util.concurrent.ForkJoinPool.commonPool();
+    }
+}
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodReference.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodReference.java
new file mode 100644
index 0000000000000..e2d1b20d29103
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodReference.java
@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+import java.util.concurrent.ForkJoinPool;
+import java.util.function.Supplier;
+
+/** */
+public class RestrictedFactoryMethodReference {
+    Supplier<?> supplier = ForkJoinPool::commonPool;
+}
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodReferenceFullName.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodReferenceFullName.java
new file mode 100644
index 0000000000000..ad86781087dda
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodReferenceFullName.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+import java.util.function.Supplier;
+
+/** */
+public class RestrictedFactoryMethodReferenceFullName {
+    Supplier<?> supplier = java.util.concurrent.ForkJoinPool::commonPool;
+}
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodStaticImport.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodStaticImport.java
new file mode 100644
index 0000000000000..02f7d1698122f
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedFactoryMethodStaticImport.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+import static java.util.concurrent.ForkJoinPool.commonPool;
+
+/** */
+public class RestrictedFactoryMethodStaticImport {
+    /** */
+    void method() {
+        Object pool = commonPool();
+    }
+}
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedJavaLangClass.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedJavaLangClass.java
new file mode 100644
index 0000000000000..2244ccc747456
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedJavaLangClass.java
@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+/** */
+public class RestrictedJavaLangClass {
+    /** */
+    void method() {
+        Thread t = new Thread();
+    }
+}
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNew.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNew.java
new file mode 100644
index 0000000000000..252a6dc65e8b9
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNew.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+import java.util.concurrent.ForkJoinPool;
+
+/** */
+public class RestrictedNew {
+    /** */
+    void method() {
+        Object pool = new ForkJoinPool();
+    }
+}
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNewFullName.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNewFullName.java
new file mode 100644
index 0000000000000..ab0663e07b474
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNewFullName.java
@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+/** */
+public class RestrictedNewFullName {
+    /** */
+    void method() {
+        Object pool = new java.util.concurrent.ForkJoinPool();
+    }
+}
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNewReference.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNewReference.java
new file mode 100644
index 0000000000000..ecdb09657639a
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNewReference.java
@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+import java.util.concurrent.ForkJoinPool;
+import java.util.function.Supplier;
+
+/** */
+public class RestrictedMethodReference {
+    Supplier<ForkJoinPool> supplier = ForkJoinPool::new;
+}
diff --git a/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNewReferenceFullName.java b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNewReferenceFullName.java
new file mode 100644
index 0000000000000..57e0f73d7ff62
--- /dev/null
+++ b/modules/checkstyle/src/test/resources/org/apache/ignite/tools/checkstyle/RestrictedNewReferenceFullName.java
@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.tools.checkstyle;
+
+import java.util.concurrent.ForkJoinPool;
+import java.util.function.Supplier;
+
+/** */
+public class RestrictedNewReferenceFullName {
+    Supplier<ForkJoinPool> supplier = java.util.concurrent.ForkJoinPool::new;
+}
diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/OperationContextAwareExecutor.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/OperationContextAwareExecutor.java
index 22ef5141739d5..6e8f6a12f9029 100644
--- a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/OperationContextAwareExecutor.java
+++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/OperationContextAwareExecutor.java
@@ -23,7 +23,15 @@
 import org.apache.ignite.internal.thread.context.function.OperationContextAwareRunnable;
 import org.jetbrains.annotations.NotNull;
 
-/** */
+/**
+ * Represents wrapper over an arbitrary {@link Executor} that automatically captures
+ * the {@link OperationContextSnapshot} of {@link OperationContext} bound to the thread from which the task is submitted
+ * for execution. It automatically restores captured {@link OperationContextSnapshot} when the task is executed.
+ *
+ * @see OperationContext
+ * @see OperationContextSnapshot
+ * @see OperationContextAwareRunnable
+ */
 public class OperationContextAwareExecutor implements Executor {
     /** */
     private final Executor delegate;
diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/OperationContextAwareExecutorService.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/OperationContextAwareExecutorService.java
new file mode 100644
index 0000000000000..5e93340bbf862
--- /dev/null
+++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/OperationContextAwareExecutorService.java
@@ -0,0 +1,129 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.thread.context.concurrent;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.apache.ignite.internal.thread.context.OperationContext;
+import org.apache.ignite.internal.thread.context.OperationContextSnapshot;
+import org.apache.ignite.internal.thread.context.function.OperationContextAwareCallable;
+import org.apache.ignite.internal.thread.context.function.OperationContextAwareRunnable;
+
+/**
+ * Represents wrapper over an arbitrary {@link ExecutorService} that automatically captures
+ * the {@link OperationContextSnapshot} of {@link OperationContext} bound to the thread from which the task is submitted
+ * for execution. It automatically restores captured {@link OperationContextSnapshot} when the task is executed.
+ *
+ * @see OperationContext
+ * @see OperationContextSnapshot
+ * @see OperationContextAwareRunnable
+ * @see OperationContextAwareCallable
+ */
+public abstract class OperationContextAwareExecutorService<E extends ExecutorService> implements ExecutorService {
+    /** */
+    protected E delegate;
+
+    /** */
+    protected OperationContextAwareExecutorService() {
+        // No-op.
+    }
+
+    /** */
+    protected OperationContextAwareExecutorService(E delegate) {
+        this.delegate = delegate;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void shutdown() {
+        delegate.shutdown();
+    }
+
+    /** {@inheritDoc} */
+    @Override public List<Runnable> shutdownNow() {
+        return delegate.shutdownNow();
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isShutdown() {
+        return delegate.isShutdown();
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isTerminated() {
+        return delegate.isTerminated();
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+        return delegate.awaitTermination(timeout, unit);
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> Future<T> submit(Callable<T> task) {
+        return delegate.submit(OperationContextAwareCallable.wrapIfContextNotEmpty(task));
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> Future<T> submit(Runnable task, T result) {
+        return delegate.submit(OperationContextAwareRunnable.wrapIfContextNotEmpty(task), result);
+    }
+
+    /** {@inheritDoc} */
+    @Override public Future<?> submit(Runnable task) {
+        return delegate.submit(OperationContextAwareRunnable.wrapIfContextNotEmpty(task));
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
+        return delegate.invokeAll(OperationContextAwareCallable.wrapIfContextNotEmpty(tasks));
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> List<Future<T>> invokeAll(
+        Collection<? extends Callable<T>> tasks,
+        long timeout,
+        TimeUnit unit
+    ) throws InterruptedException {
+        return delegate.invokeAll(OperationContextAwareCallable.wrapIfContextNotEmpty(tasks), timeout, unit);
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
+        return delegate.invokeAny(OperationContextAwareCallable.wrapIfContextNotEmpty(tasks));
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> T invokeAny(
+        Collection<? extends Callable<T>> tasks,
+        long timeout,
+        TimeUnit unit
+    ) throws InterruptedException, ExecutionException, TimeoutException {
+        return delegate.invokeAny(OperationContextAwareCallable.wrapIfContextNotEmpty(tasks), timeout, unit);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void execute(Runnable command) {
+        delegate.execute(OperationContextAwareRunnable.wrapIfContextNotEmpty(command));
+    }
+}
diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/OperationContextAwareScheduledExecutorService.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/OperationContextAwareScheduledExecutorService.java
new file mode 100644
index 0000000000000..cf8149efd6a61
--- /dev/null
+++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/OperationContextAwareScheduledExecutorService.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.thread.context.concurrent;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import org.apache.ignite.internal.thread.context.OperationContext;
+import org.apache.ignite.internal.thread.context.OperationContextSnapshot;
+import org.apache.ignite.internal.thread.context.function.OperationContextAwareCallable;
+import org.apache.ignite.internal.thread.context.function.OperationContextAwareRunnable;
+
+/**
+ * Represents wrapper over an arbitrary {@link ScheduledExecutorService} that automatically captures
+ * the {@link OperationContextSnapshot} of {@link OperationContext} bound to the thread from which the task is submitted
+ * for execution. It automatically restores captured {@link OperationContextSnapshot} when the task is executed.
+ *
+ * @see OperationContextAwareExecutorService
+ * @see OperationContext
+ * @see OperationContextSnapshot
+ * @see OperationContextAwareRunnable
+ * @see OperationContextAwareCallable
+ */
+public abstract class OperationContextAwareScheduledExecutorService extends OperationContextAwareExecutorService<ScheduledExecutorService>
+    implements ScheduledExecutorService {
+    /** */
+    protected OperationContextAwareScheduledExecutorService(ScheduledExecutorService delegate) {
+        super(delegate);
+    }
+
+    /** {@inheritDoc} */
+    @Override public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
+        return delegate.schedule(OperationContextAwareRunnable.wrapIfContextNotEmpty(command), delay, unit);
+    }
+
+    /** {@inheritDoc} */
+    @Override public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
+        return delegate.schedule(OperationContextAwareCallable.wrapIfContextNotEmpty(callable), delay, unit);
+    }
+
+    /** {@inheritDoc} */
+    @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
+        return delegate.scheduleAtFixedRate(
+            OperationContextAwareRunnable.wrapIfContextNotEmpty(command),
+            initialDelay,
+            period,
+            unit
+        );
+    }
+
+    /** {@inheritDoc} */
+    @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
+        return delegate.scheduleWithFixedDelay(
+            OperationContextAwareRunnable.wrapIfContextNotEmpty(command),
+            initialDelay,
+            delay,
+            unit
+        );
+    }
+}
diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/OperationContextAwareCallable.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/OperationContextAwareCallable.java
index 909a4d88dcb83..eb63fbe0d7ace 100644
--- a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/OperationContextAwareCallable.java
+++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/OperationContextAwareCallable.java
@@ -54,7 +54,9 @@ public static <T> Callable<T> wrap(Callable<T> delegate) {
      * {@link OperationContextSnapshot} will be restored before {@link Callable} execution, potentially in another
      * thread.
      * If {@link OperationContext} holds no data when this method is called, it does nothing and returns original
-     * {@link Callable}.
+     * {@link Callable}. It helps to avoid creation of unnecessary wrappers when it is known in advance that
+     * {@link Callable#call()} will be called from a thread that does not have an {@link OperationContext} bound to it
+     * (e.g. thread of Thread Pool).
      */
     public static <T> Callable<T> wrapIfContextNotEmpty(Callable<T> delegate) {
         return wrap(delegate, OperationContextAwareCallable::new, true);
diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/OperationContextAwareRunnable.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/OperationContextAwareRunnable.java
index 04f11ba710768..7a7782da5897f 100644
--- a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/OperationContextAwareRunnable.java
+++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/OperationContextAwareRunnable.java
@@ -51,7 +51,9 @@ public static Runnable wrap(Runnable delegate) {
      * {@link OperationContextSnapshot} will be restored before {@link Runnable} execution, potentially in another
      * thread.
      * If {@link OperationContext} holds no data when this method is called, it does nothing and returns original
-     * {@link Runnable}.
+     * {@link Runnable}. It helps to avoid creation of unnecessary wrappers when it is known in advance that
+     * {@link Runnable#run()} will be called from a thread that does not have an {@link OperationContext} bound to it
+     * (e.g. thread of Thread Pool).
      */
     public static Runnable wrapIfContextNotEmpty(Runnable delegate) {
         return wrap(delegate, OperationContextAwareRunnable::new, true);
diff --git a/modules/commons/src/main/java/org/apache/ignite/thread/IgniteThread.java b/modules/commons/src/main/java/org/apache/ignite/thread/IgniteThread.java
index 3e5104ae55c32..9c2e7590c8cba 100644
--- a/modules/commons/src/main/java/org/apache/ignite/thread/IgniteThread.java
+++ b/modules/commons/src/main/java/org/apache/ignite/thread/IgniteThread.java
@@ -237,7 +237,7 @@ public static IgniteThread current() {
      * @param igniteInstanceName Ignite instance name.
      * @return New thread name.
      */
-    protected static String createName(long num, String threadName, String igniteInstanceName) {
+    public static String createName(long num, String threadName, String igniteInstanceName) {
         return threadName + "-#" + num + (igniteInstanceName != null ? '%' + igniteInstanceName + '%' : "");
     }
 
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheAbstractJdbcStore.java b/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheAbstractJdbcStore.java
index 9d59c9ea29a63..7007ca69c640d 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheAbstractJdbcStore.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheAbstractJdbcStore.java
@@ -37,7 +37,6 @@
 import java.util.UUID;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
@@ -61,7 +60,6 @@
 import org.apache.ignite.cache.store.jdbc.dialect.SQLServerDialect;
 import org.apache.ignite.internal.binary.BinaryObjectEx;
 import org.apache.ignite.internal.binary.BinaryUtils;
-import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.internal.util.tostring.GridToStringExclude;
 import org.apache.ignite.internal.util.typedef.C1;
 import org.apache.ignite.internal.util.typedef.F;
@@ -81,6 +79,7 @@
 import static org.apache.ignite.cache.store.jdbc.CacheJdbcPojoStoreFactory.DFLT_PARALLEL_LOAD_CACHE_MINIMUM_THRESHOLD;
 import static org.apache.ignite.cache.store.jdbc.CacheJdbcPojoStoreFactory.DFLT_WRITE_ATTEMPTS;
 import static org.apache.ignite.cache.store.jdbc.JdbcTypesTransformer.NUMERIC_TYPES;
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newFixedThreadPool;
 
 /**
  * Implementation of {@link CacheStore} backed by JDBC.
@@ -666,7 +665,7 @@ protected Integer columnIndex(Map<String, Integer> loadColIdxs, String dbName) {
         String cacheName = session().cacheName();
 
         try {
-            pool = Executors.newFixedThreadPool(maxPoolSize, new IgniteThreadFactory(ignite.name(), CACHE_LOADER_THREAD_NAME));
+            pool = newFixedThreadPool(CACHE_LOADER_THREAD_NAME, ignite.name(), maxPoolSize);
 
             Collection<Future<?>> futs = new ArrayList<>();
 
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/GridKernalContextImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/GridKernalContextImpl.java
index e1676be483ebf..83b9e3defc35e 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/GridKernalContextImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/GridKernalContextImpl.java
@@ -31,7 +31,6 @@
 import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.Executor;
-import java.util.concurrent.ForkJoinPool;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.IgniteException;
 import org.apache.ignite.IgniteLogger;
@@ -102,6 +101,7 @@
 import org.apache.ignite.internal.processors.timeout.GridTimeoutProcessor;
 import org.apache.ignite.internal.processors.tracing.Tracing;
 import org.apache.ignite.internal.suggestions.GridPerformanceSuggestions;
+import org.apache.ignite.internal.thread.pool.IgniteForkJoinPool;
 import org.apache.ignite.internal.util.IgniteExceptionRegistry;
 import org.apache.ignite.internal.util.spring.IgniteSpringHelper;
 import org.apache.ignite.internal.util.tostring.GridToStringExclude;
@@ -1114,7 +1114,7 @@ public void recoveryMode(boolean recoveryMode) {
     /** {@inheritDoc} */
     @Override public Executor getAsyncContinuationExecutor() {
         return config().getAsyncContinuationExecutor() == null
-                ? ForkJoinPool.commonPool()
+                ? IgniteForkJoinPool.commonPool()
                 : config().getAsyncContinuationExecutor();
     }
 
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java b/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
index a27c0623edafc..eff029b4dfbbd 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
@@ -39,7 +39,6 @@
 import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import javax.cache.CacheException;
@@ -175,7 +174,6 @@
 import org.apache.ignite.internal.suggestions.JvmConfigurationSuggestions;
 import org.apache.ignite.internal.suggestions.OsConfigurationSuggestions;
 import org.apache.ignite.internal.systemview.ConfigurationViewWalker;
-import org.apache.ignite.internal.thread.pool.IgniteStripedExecutor;
 import org.apache.ignite.internal.util.TimeBag;
 import org.apache.ignite.internal.util.future.GridCompoundFuture;
 import org.apache.ignite.internal.util.future.GridFinishedFuture;
@@ -1364,37 +1362,6 @@ private GridProcessor securityProcessor() throws IgniteCheckedException {
             : new NoOpIgniteSecurityProcessor(ctx);
     }
 
-    /**
-     * Create description of an executor service for logging.
-     *
-     * @param execSvcName Name of the service.
-     * @param execSvc Service to create a description for.
-     */
-    private String createExecutorDescription(String execSvcName, ExecutorService execSvc) {
-        int poolSize = 0;
-        int poolActiveThreads = 0;
-        int poolQSize = 0;
-
-        if (execSvc instanceof ThreadPoolExecutor) {
-            ThreadPoolExecutor exec = (ThreadPoolExecutor)execSvc;
-
-            poolSize = exec.getPoolSize();
-            poolActiveThreads = Math.min(poolSize, exec.getActiveCount());
-            poolQSize = exec.getQueue().size();
-        }
-        else if (execSvc instanceof IgniteStripedExecutor) {
-            IgniteStripedExecutor exec = (IgniteStripedExecutor)execSvc;
-
-            poolSize = exec.stripesCount();
-            poolActiveThreads = exec.activeStripesCount();
-            poolQSize = exec.queueSize();
-        }
-
-        int poolIdleThreads = poolSize - poolActiveThreads;
-
-        return execSvcName + " [active=" + poolActiveThreads + ", idle=" + poolIdleThreads + ", qSize=" + poolQSize + "]";
-    }
-
     /**
      * Validates common configuration parameters.
      *
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java b/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
index 7f4529a6a1951..2086cbe0a044a 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
@@ -38,7 +38,6 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -141,6 +140,7 @@
 import static org.apache.ignite.cache.CacheWriteSynchronizationMode.FULL_SYNC;
 import static org.apache.ignite.internal.IgniteComponentType.SPRING;
 import static org.apache.ignite.internal.processors.task.TaskExecutionOptions.options;
+import static org.apache.ignite.internal.thread.pool.IgniteScheduledThreadPoolExecutor.newSingleThreadScheduledExecutor;
 import static org.apache.ignite.internal.util.IgniteUtils.EMPTY_STRS;
 import static org.apache.ignite.internal.util.IgniteUtils.IGNITE_MBEANS_DISABLED;
 import static org.apache.ignite.plugin.segmentation.SegmentationPolicy.RESTART_JVM;
@@ -342,7 +342,7 @@ public static boolean stop(@Nullable String name, boolean cancel,
      */
     @Deprecated
     public static boolean stop(@Nullable String name, boolean cancel, boolean stopNotStarted, long timeoutMs) {
-        final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
+        final ScheduledExecutorService executor = newSingleThreadScheduledExecutor("ignite-stop-await-worker", name);
 
         // Schedule delayed node killing if graceful stopping will be not finished within timeout.
         executor.schedule(new Runnable() {
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/jdbc2/JdbcQueryTask.java b/modules/core/src/main/java/org/apache/ignite/internal/jdbc2/JdbcQueryTask.java
index 2d29a65fd9aa7..773976bc74edf 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/jdbc2/JdbcQueryTask.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/jdbc2/JdbcQueryTask.java
@@ -25,7 +25,6 @@
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import org.apache.ignite.Ignite;
@@ -45,6 +44,8 @@
 import org.apache.ignite.lang.IgniteCallable;
 import org.apache.ignite.resources.IgniteInstanceResource;
 
+import static org.apache.ignite.internal.thread.pool.IgniteScheduledThreadPoolExecutor.newSingleThreadScheduledExecutor;
+
 /**
  * Task for SQL queries execution through {@link IgniteJdbcDriver}.
  * <p>
@@ -61,7 +62,7 @@ class JdbcQueryTask implements IgniteCallable<JdbcQueryTaskResult> {
         IgniteSystemProperties.IGNITE_JDBC_DRIVER_CURSOR_REMOVE_DELAY, 600000);
 
     /** Scheduler. */
-    private static final ScheduledExecutorService SCHEDULER = Executors.newScheduledThreadPool(1);
+    private static final ScheduledExecutorService SCHEDULER = newSingleThreadScheduledExecutor("jdbc-cursor-close-worker", null);
 
     /** Open cursors. */
     private static final ConcurrentMap<UUID, Cursor> CURSORS = new ConcurrentHashMap<>();
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/FindAndDeleteGarbageInPersistenceClosure.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/FindAndDeleteGarbageInPersistenceClosure.java
index 7d5430fdc2724..4206f1f64a56c 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/FindAndDeleteGarbageInPersistenceClosure.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/FindAndDeleteGarbageInPersistenceClosure.java
@@ -27,7 +27,6 @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
@@ -51,6 +50,8 @@
 import org.apache.ignite.resources.IgniteInstanceResource;
 import org.apache.ignite.resources.LoggerResource;
 
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newFixedThreadPool;
+
 /**
  * Class contains logic of finding data of already destroyed caches in running cache groups.
  *
@@ -60,6 +61,9 @@ public class FindAndDeleteGarbageInPersistenceClosure implements IgniteCallable<
     /** */
     private static final long serialVersionUID = 0L;
 
+    /** */
+    private static final String THREAD_NAME_PREFIX = "persistence-clean-worker";
+
     /** Ignite. */
     @IgniteInstanceResource
     private transient IgniteEx ignite;
@@ -97,7 +101,7 @@ public FindAndDeleteGarbageInPersistenceClosure(String[] grpNames, boolean delet
 
     /** {@inheritDoc} */
     @Override public FindAndDeleteGarbageInPersistenceJobResult call() throws Exception {
-        calcExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+        calcExecutor = newFixedThreadPool(THREAD_NAME_PREFIX, ignite.name(), Runtime.getRuntime().availableProcessors());
 
         try {
             return call0();
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/ValidateIndexesClosure.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/ValidateIndexesClosure.java
index 55ab42a9a4d63..42a94c5f9fa9d 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/ValidateIndexesClosure.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/ValidateIndexesClosure.java
@@ -30,7 +30,6 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
@@ -90,6 +89,7 @@
 import static org.apache.ignite.internal.processors.cache.verify.IdleVerifyUtility.compareUpdateCounters;
 import static org.apache.ignite.internal.processors.cache.verify.IdleVerifyUtility.formatUpdateCountersDiff;
 import static org.apache.ignite.internal.processors.cache.verify.IdleVerifyUtility.getUpdateCountersSnapshot;
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newFixedThreadPool;
 import static org.apache.ignite.internal.util.IgniteUtils.error;
 
 /**
@@ -104,6 +104,9 @@ public class ValidateIndexesClosure implements IgniteCallable<ValidateIndexesJob
     /** */
     private static final long serialVersionUID = 0L;
 
+    /** */
+    private static final String THREAD_NAME_PREFIX = "idx-validate-worker";
+
     /** Exception message throwing when closure was cancelled. */
     public static final String CANCELLED_MSG = "Closure of index validation was cancelled.";
 
@@ -194,7 +197,7 @@ public ValidateIndexesClosure(
 
     /** {@inheritDoc} */
     @Override public ValidateIndexesJobResult call() throws Exception {
-        calcExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+        calcExecutor = newFixedThreadPool(THREAD_NAME_PREFIX, ignite.name(), Runtime.getRuntime().availableProcessors());
 
         try {
             return call0();
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/VerifyBackupPartitionsTask.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/VerifyBackupPartitionsTask.java
index 2fe0378fa5d09..54c5f1c41a07c 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/VerifyBackupPartitionsTask.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/VerifyBackupPartitionsTask.java
@@ -25,7 +25,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
@@ -57,6 +57,7 @@
 import org.apache.ignite.internal.processors.cache.verify.GridNotIdleException;
 import org.apache.ignite.internal.processors.cache.verify.PartitionHashRecord;
 import org.apache.ignite.internal.processors.task.GridInternal;
+import org.apache.ignite.internal.thread.pool.IgniteForkJoinPool;
 import org.apache.ignite.internal.util.typedef.F;
 import org.apache.ignite.internal.util.typedef.internal.U;
 import org.apache.ignite.lang.IgniteInClosure;
@@ -94,7 +95,7 @@ public class VerifyBackupPartitionsTask extends ComputeTaskAdapter<CacheIdleVeri
     public static final String CP_REASON = "VerifyBackupPartitions";
 
     /** Shared for tests. */
-    public static Supplier<ForkJoinPool> poolSupplier = ForkJoinPool::commonPool;
+    public static Supplier<ExecutorService> poolSupplier = IgniteForkJoinPool::commonPool;
 
     /** Injected logger. */
     @LoggerResource
@@ -345,7 +346,7 @@ private List<Future<Map<PartitionKey, PartitionHashRecord>>> calcPartitionHashAs
                 if (grpCtx == null)
                     continue;
 
-                ForkJoinPool pool = poolSupplier.get();
+                ExecutorService pool = poolSupplier.get();
 
                 for (GridDhtLocalPartition part : grpCtx.topology().currentLocalPartitions())
                     partHashCalcFutures.add(calculatePartitionHashAsync(pool, grpCtx, part, this::isCancelled));
@@ -489,7 +490,7 @@ private boolean isCacheMatchFilter(DynamicCacheDescriptor desc) {
          * @param cancelled Supplier of cancelled status.
          */
         private Future<Map<PartitionKey, PartitionHashRecord>> calculatePartitionHashAsync(
-            final ForkJoinPool pool,
+            final ExecutorService pool,
             final CacheGroupContext gctx,
             final GridDhtLocalPartition part,
             final BooleanSupplier cancelled
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairTask.java b/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairTask.java
index 8cbdf15845856..0843658042cd2 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairTask.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairTask.java
@@ -24,7 +24,6 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 import javax.cache.CacheException;
@@ -41,6 +40,7 @@
 import org.apache.ignite.internal.processors.cache.distributed.near.consistency.IgniteIrreparableConsistencyViolationException;
 import org.apache.ignite.internal.processors.cache.persistence.CacheDataRow;
 import org.apache.ignite.internal.thread.context.Scope;
+import org.apache.ignite.internal.thread.pool.IgniteForkJoinPool;
 import org.apache.ignite.internal.util.GridConcurrentHashSet;
 import org.apache.ignite.internal.util.lang.GridCursor;
 import org.apache.ignite.internal.util.typedef.F;
@@ -103,7 +103,7 @@ protected ConsistencyRepairJob(ConsistencyRepairCommandArg arg, boolean debug) {
             AtomicReference<Exception> err = new AtomicReference<>();
 
             Map<Boolean, List<IgniteBiTuple<Integer, String>>> res = Arrays.stream(arg.partitions())
-                .mapToObj(p -> F.t(p, ForkJoinPool.commonPool().submit(() -> processPartition(p, arg))))
+                .mapToObj(p -> F.t(p, IgniteForkJoinPool.commonPool().submit(() -> processPartition(p, arg))))
                 .map(t -> {
                     try {
                         return F.t(t.get1(), t.get2().get());
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java b/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java
index ef79d00696910..9294efd015356 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java
@@ -56,7 +56,6 @@
 import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
@@ -103,7 +102,6 @@
 import org.apache.ignite.internal.processors.tracing.MTC.TraceSurroundings;
 import org.apache.ignite.internal.processors.tracing.Span;
 import org.apache.ignite.internal.processors.tracing.SpanTags;
-import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.internal.thread.context.Scope;
 import org.apache.ignite.internal.util.GridBoundedConcurrentLinkedHashSet;
 import org.apache.ignite.internal.util.IgniteUtils;
@@ -166,6 +164,8 @@
 import static org.apache.ignite.internal.processors.tracing.SpanType.COMMUNICATION_ORDERED_PROCESS;
 import static org.apache.ignite.internal.processors.tracing.SpanType.COMMUNICATION_REGULAR_PROCESS;
 import static org.apache.ignite.internal.processors.tracing.messages.TraceableMessagesTable.traceName;
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newCachedThreadPool;
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newFixedThreadPool;
 import static org.apache.ignite.internal.util.lang.ClusterNodeFunc.localNode;
 import static org.apache.ignite.internal.util.lang.ClusterNodeFunc.remoteNodes;
 import static org.apache.ignite.internal.util.nio.GridNioBackPressureControl.threadProcessingMessage;
@@ -634,7 +634,7 @@ public void runIoTest(
         final boolean procFromNioThread,
         final List<ClusterNode> nodes
     ) {
-        ExecutorService svc = Executors.newFixedThreadPool(threads + 1);
+        ExecutorService svc = newFixedThreadPool("io-latency-inspector", ctx.igniteInstanceName(), threads + 1);
 
         final AtomicBoolean warmupFinished = new AtomicBoolean();
         final AtomicBoolean done = new AtomicBoolean();
@@ -4292,8 +4292,7 @@ private final class TcpCommunicationInverseConnectionHandler implements Connecti
         /**
          * Executor service to send special communication message.
          */
-        private ExecutorService responseSendService = Executors
-            .newCachedThreadPool(new IgniteThreadFactory(ctx.igniteInstanceName(), "io-send-service"));
+        private final ExecutorService responseSendService = newCachedThreadPool("io-send-service", ctx.igniteInstanceName());
 
         /**
          * Discovery event listener (works only on client nodes for now) notified when
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/plugin/IgniteLogInfoProviderImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/plugin/IgniteLogInfoProviderImpl.java
index 01f988e3a1305..b39e391f55120 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/plugin/IgniteLogInfoProviderImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/plugin/IgniteLogInfoProviderImpl.java
@@ -35,7 +35,6 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ThreadPoolExecutor;
 import org.apache.ignite.Ignite;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.IgniteException;
@@ -57,6 +56,7 @@
 import org.apache.ignite.internal.processors.cache.persistence.IgniteCacheDatabaseSharedManager;
 import org.apache.ignite.internal.processors.port.GridPortRecord;
 import org.apache.ignite.internal.thread.pool.IgniteStripedExecutor;
+import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.internal.util.typedef.F;
 import org.apache.ignite.internal.util.typedef.internal.CU;
 import org.apache.ignite.internal.util.typedef.internal.S;
@@ -778,8 +778,8 @@ String createExecutorDescription(String execSvcName, ExecutorService execSvc) {
         int poolActiveThreads = 0;
         int poolQSize = 0;
 
-        if (execSvc instanceof ThreadPoolExecutor) {
-            ThreadPoolExecutor exec = (ThreadPoolExecutor)execSvc;
+        if (execSvc instanceof IgniteThreadPoolExecutor) {
+            IgniteThreadPoolExecutor exec = (IgniteThreadPoolExecutor)execSvc;
 
             poolSize = exec.getPoolSize();
             poolActiveThreads = Math.min(poolSize, exec.getActiveCount());
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java
index 5c91859b1dc9b..410bac3545fc2 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java
@@ -38,7 +38,6 @@
 import java.util.SortedSet;
 import java.util.UUID;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
@@ -114,7 +113,6 @@
 import org.apache.ignite.internal.processors.platform.client.cache.ImmutableArraySet;
 import org.apache.ignite.internal.processors.security.SecurityContext;
 import org.apache.ignite.internal.processors.task.GridInternal;
-import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.internal.thread.context.Scope;
 import org.apache.ignite.internal.transactions.IgniteTxHeuristicCheckedException;
 import org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException;
@@ -166,6 +164,7 @@
 import static org.apache.ignite.internal.processors.dr.GridDrType.DR_NONE;
 import static org.apache.ignite.internal.processors.metric.impl.MetricUtils.cacheMetricsRegistryName;
 import static org.apache.ignite.internal.processors.task.TaskExecutionOptions.options;
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newFixedThreadPool;
 import static org.apache.ignite.transactions.TransactionConcurrency.OPTIMISTIC;
 import static org.apache.ignite.transactions.TransactionConcurrency.PESSIMISTIC;
 import static org.apache.ignite.transactions.TransactionIsolation.READ_COMMITTED;
@@ -1076,8 +1075,7 @@ public List<GridCacheClearAllRunnable<K, V>> splitClearLocally(boolean srv, bool
 
             try {
                 if (jobs.size() > 1) {
-                    execSvc = Executors.newFixedThreadPool(jobs.size() - 1,
-                        new IgniteThreadFactory(ctx.igniteInstanceName(), "async-cache-cleaner"));
+                    execSvc = newFixedThreadPool("async-cache-cleaner", ctx.igniteInstanceName(), jobs.size() - 1);
 
                     for (int i = 1; i < jobs.size(); i++)
                         execSvc.execute(jobs.get(i));
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java
index 1606c9c5a7578..47480dace142a 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java
@@ -27,9 +27,8 @@
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ForkJoinTask;
-import java.util.concurrent.ForkJoinWorkerThread;
 import java.util.concurrent.Future;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.RejectedExecutionException;
@@ -62,6 +61,7 @@
 import org.apache.ignite.internal.processors.cache.persistence.pagemem.PageMemoryEx;
 import org.apache.ignite.internal.processors.cache.persistence.partstate.PartitionAllocationMap;
 import org.apache.ignite.internal.processors.cache.persistence.wal.WALPointer;
+import org.apache.ignite.internal.thread.pool.IgniteForkJoinPool;
 import org.apache.ignite.internal.thread.pool.IgniteStripedExecutor;
 import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.internal.util.GridConcurrentHashSet;
@@ -495,7 +495,7 @@ private GridConcurrentMultiPairQueue<PageMemoryEx, FullPageId> splitAndSortCpPag
             Comparator<FullPageId> cmp = Comparator.comparingInt(FullPageId::groupId)
                 .thenComparingLong(FullPageId::effectivePageId);
 
-            ForkJoinPool pool = null;
+            ExecutorService pool = null;
 
             for (T2<PageMemoryEx, FullPageId[]> pagesPerReg : cpPagesPerRegion) {
                 if (pagesPerReg.getValue().length >= parallelSortThreshold)
@@ -518,23 +518,14 @@ private GridConcurrentMultiPairQueue<PageMemoryEx, FullPageId> splitAndSortCpPag
      * @param cmp Cmp.
      * @return ForkJoinPool instance, check {@link ForkJoinTask#fork()} realization.
      */
-    private static ForkJoinPool parallelSortInIsolatedPool(
+    private ExecutorService parallelSortInIsolatedPool(
         FullPageId[] pagesArr,
         Comparator<FullPageId> cmp,
-        ForkJoinPool pool
+        ExecutorService pool
     ) throws IgniteCheckedException {
-        ForkJoinPool.ForkJoinWorkerThreadFactory factory = new ForkJoinPool.ForkJoinWorkerThreadFactory() {
-            @Override public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
-                ForkJoinWorkerThread worker = ForkJoinPool.defaultForkJoinWorkerThreadFactory.newThread(pool);
-
-                worker.setName("checkpoint-pages-sorter-" + worker.getPoolIndex());
-
-                return worker;
-            }
-        };
-
-        ForkJoinPool execPool = pool == null ?
-            new ForkJoinPool(PARALLEL_SORT_THREADS + 1, factory, null, false) : pool;
+        ExecutorService execPool = pool == null
+            ? new IgniteForkJoinPool("checkpoint-pages-sorter", igniteInstanceName, PARALLEL_SORT_THREADS + 1, null, false)
+            : pool;
 
         Future<?> sortTask = execPool.submit(() -> Arrays.parallelSort(pagesArr, cmp));
 
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/pagemem/PageMemoryImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/pagemem/PageMemoryImpl.java
index 82a026085c795..9913aabd5cfa0 100755
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/pagemem/PageMemoryImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/pagemem/PageMemoryImpl.java
@@ -29,8 +29,6 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ThreadLocalRandom;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLong;
@@ -76,7 +74,7 @@
 import org.apache.ignite.internal.processors.cache.persistence.wal.crc.IgniteDataIntegrityViolationException;
 import org.apache.ignite.internal.processors.compress.CompressionProcessor;
 import org.apache.ignite.internal.processors.query.GridQueryRowCacheCleaner;
-import org.apache.ignite.internal.thread.IgniteThreadFactory;
+import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.internal.util.GridConcurrentHashSet;
 import org.apache.ignite.internal.util.GridLongList;
 import org.apache.ignite.internal.util.GridMultiCollectionWrapper;
@@ -96,6 +94,7 @@
 
 import static java.lang.Boolean.FALSE;
 import static java.lang.Boolean.TRUE;
+import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.apache.ignite.IgniteSystemProperties.IGNITE_DELAYED_REPLACED_PAGE_WRITE;
 import static org.apache.ignite.IgniteSystemProperties.IGNITE_LOADED_PAGES_BACKWARD_SHIFT_MAP;
 import static org.apache.ignite.IgniteSystemProperties.getBoolean;
@@ -332,13 +331,14 @@ public PageMemoryImpl(
         
         this.dataRegionCfg = dataRegionCfg;
 
-        asyncRunner = new ThreadPoolExecutor(
+        asyncRunner = new IgniteThreadPoolExecutor(
+            "page-mem-op",
+            ctx.igniteInstanceName(),
             0,
             Runtime.getRuntime().availableProcessors(),
-            30L,
-            TimeUnit.SECONDS,
-            new ArrayBlockingQueue<>(Runtime.getRuntime().availableProcessors()),
-            new IgniteThreadFactory(ctx.igniteInstanceName(), "page-mem-op"));
+            SECONDS.toMillis(30),
+            new ArrayBlockingQueue<>(Runtime.getRuntime().availableProcessors())
+        );
         
         switch (dataRegionCfg.getPageReplacementMode()) {
             case RANDOM_LRU:
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/metric/PushMetricsExporterAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/metric/PushMetricsExporterAdapter.java
index bb12490060af1..becde2cbdbb7c 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/metric/PushMetricsExporterAdapter.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/metric/PushMetricsExporterAdapter.java
@@ -17,11 +17,9 @@
 
 package org.apache.ignite.internal.processors.metric;
 
-import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.function.Predicate;
-import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.spi.IgniteSpiAdapter;
 import org.apache.ignite.spi.IgniteSpiContext;
 import org.apache.ignite.spi.IgniteSpiException;
@@ -31,6 +29,7 @@
 import org.jetbrains.annotations.Nullable;
 
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.apache.ignite.internal.thread.pool.IgniteScheduledThreadPoolExecutor.newSingleThreadScheduledExecutor;
 
 /**
  * Base class for exporters that pushes metrics to the external system.
@@ -100,8 +99,7 @@ public long getPeriod() {
     @Override protected void onContextInitialized0(IgniteSpiContext spiCtx) throws IgniteSpiException {
         super.onContextInitialized0(spiCtx);
 
-        execSvc = Executors.newSingleThreadScheduledExecutor(new IgniteThreadFactory(igniteInstanceName,
-            "push-metrics-exporter"));
+        execSvc = newSingleThreadScheduledExecutor("push-metrics-exporter", igniteInstanceName);
 
         fut = execSvc.scheduleWithFixedDelay(() -> {
             try {
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java
index 9f06eb35ab41e..1cc0d4ff023d3 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java
@@ -24,11 +24,9 @@
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.IgniteException;
 import org.apache.ignite.IgniteLogger;
@@ -42,23 +40,18 @@
 import org.apache.ignite.internal.managers.communication.GridIoPolicy;
 import org.apache.ignite.internal.processors.GridProcessorAdapter;
 import org.apache.ignite.internal.processors.plugin.IgnitePluginProcessor;
-import org.apache.ignite.internal.processors.security.IgniteSecurity;
 import org.apache.ignite.internal.processors.timeout.GridTimeoutProcessor;
 import org.apache.ignite.internal.systemview.StripedExecutorTaskViewWalker;
 import org.apache.ignite.internal.thread.pool.IgniteStripedExecutor;
 import org.apache.ignite.internal.thread.pool.IgniteStripedThreadPoolExecutor;
 import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.internal.thread.pool.OperationContextAwareIoPool;
-import org.apache.ignite.internal.thread.pool.OperationContextAwareStripedExecutor;
-import org.apache.ignite.internal.thread.pool.OperationContextAwareStripedThreadPoolExecutor;
-import org.apache.ignite.internal.thread.pool.OperationContextAwareThreadPoolExecutor;
 import org.apache.ignite.internal.thread.pool.SameThreadExecutor;
 import org.apache.ignite.internal.util.tostring.GridToStringExclude;
 import org.apache.ignite.internal.util.typedef.F;
 import org.apache.ignite.internal.util.typedef.internal.CU;
 import org.apache.ignite.internal.util.typedef.internal.LT;
 import org.apache.ignite.internal.util.typedef.internal.U;
-import org.apache.ignite.internal.util.worker.GridWorkerListener;
 import org.apache.ignite.internal.worker.WorkersRegistry;
 import org.apache.ignite.lang.IgniteInClosure;
 import org.apache.ignite.metric.MetricRegistry;
@@ -153,15 +146,15 @@ public class PoolProcessor extends GridProcessorAdapter {
 
     /** Executor service. */
     @GridToStringExclude
-    private ThreadPoolExecutor execSvc;
+    private IgniteThreadPoolExecutor execSvc;
 
     /** Executor service for services. */
     @GridToStringExclude
-    private ThreadPoolExecutor svcExecSvc;
+    private IgniteThreadPoolExecutor svcExecSvc;
 
     /** System executor service. */
     @GridToStringExclude
-    private ThreadPoolExecutor sysExecSvc;
+    private IgniteThreadPoolExecutor sysExecSvc;
 
     /** */
     @GridToStringExclude
@@ -169,11 +162,11 @@ public class PoolProcessor extends GridProcessorAdapter {
 
     /** Management executor service. */
     @GridToStringExclude
-    private ThreadPoolExecutor mgmtExecSvc;
+    private IgniteThreadPoolExecutor mgmtExecSvc;
 
     /** P2P executor service. */
     @GridToStringExclude
-    private ThreadPoolExecutor p2pExecSvc;
+    private IgniteThreadPoolExecutor p2pExecSvc;
 
     /** Data streamer executor service. */
     @GridToStringExclude
@@ -181,22 +174,22 @@ public class PoolProcessor extends GridProcessorAdapter {
 
     /** REST requests executor service. */
     @GridToStringExclude
-    private ThreadPoolExecutor restExecSvc;
+    private IgniteThreadPoolExecutor restExecSvc;
 
     /** Utility cache executor service. */
-    private ThreadPoolExecutor utilityCacheExecSvc;
+    private IgniteThreadPoolExecutor utilityCacheExecSvc;
 
     /** Affinity executor service. */
     @GridToStringExclude
-    private ThreadPoolExecutor affExecSvc;
+    private IgniteThreadPoolExecutor affExecSvc;
 
     /** Indexing pool. */
     @GridToStringExclude
-    private ThreadPoolExecutor idxExecSvc;
+    private IgniteThreadPoolExecutor idxExecSvc;
 
     /** Thread pool for create/rebuild indexes. */
     @GridToStringExclude
-    private ThreadPoolExecutor buildIdxExecSvc;
+    private IgniteThreadPoolExecutor buildIdxExecSvc;
 
     /** Continuous query executor service. */
     @GridToStringExclude
@@ -204,23 +197,23 @@ public class PoolProcessor extends GridProcessorAdapter {
 
     /** Query executor service. */
     @GridToStringExclude
-    private ThreadPoolExecutor qryExecSvc;
+    private IgniteThreadPoolExecutor qryExecSvc;
 
     /** Query executor service. */
     @GridToStringExclude
-    private ThreadPoolExecutor schemaExecSvc;
+    private IgniteThreadPoolExecutor schemaExecSvc;
 
     /** Rebalance executor service. */
     @GridToStringExclude
-    private ThreadPoolExecutor rebalanceExecSvc;
+    private IgniteThreadPoolExecutor rebalanceExecSvc;
 
     /** Snapshot task executor service. */
     @GridToStringExclude
-    private ThreadPoolExecutor snpExecSvc;
+    private IgniteThreadPoolExecutor snpExecSvc;
 
     /** Executor service for thin clients. */
     @GridToStringExclude
-    private ExecutorService thinClientExec;
+    private IgniteThreadPoolExecutor thinClientExec;
 
     /** Rebalance striped executor service. */
     @GridToStringExclude
@@ -228,13 +221,13 @@ public class PoolProcessor extends GridProcessorAdapter {
 
     /** Executor to perform a data pages scanning during cache group re-encryption. */
     @GridToStringExclude
-    private ThreadPoolExecutor reencryptExecSvc;
+    private IgniteThreadPoolExecutor reencryptExecSvc;
 
     /** Map of {@link IoPool}-s injected by Ignite plugins. */
     private final IoPool[] extPools = new IoPool[128];
 
     /** Custom named pools. */
-    private Map<String, ThreadPoolExecutor> customExecs;
+    private Map<String, IgniteThreadPoolExecutor> customExecs;
 
     /** Pools to check for starvation. */
     private Map<String, ExecutorService> starvationExecs = new HashMap<>();
@@ -302,7 +295,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
         validateThreadPoolSize(cfg.getPublicThreadPoolSize(), "public");
 
-        execSvc = createExecutorService(
+        execSvc = new IgniteThreadPoolExecutor(
             "pub",
             cfg.getIgniteInstanceName(),
             cfg.getPublicThreadPoolSize(),
@@ -318,7 +311,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
         validateThreadPoolSize(cfg.getServiceThreadPoolSize(), "service");
 
-        svcExecSvc = createExecutorService(
+        svcExecSvc = new IgniteThreadPoolExecutor(
             "svc",
             cfg.getIgniteInstanceName(),
             cfg.getServiceThreadPoolSize(),
@@ -332,7 +325,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
         validateThreadPoolSize(cfg.getSystemThreadPoolSize(), "system");
 
-        sysExecSvc = createExecutorService(
+        sysExecSvc = new IgniteThreadPoolExecutor(
             "sys",
             cfg.getIgniteInstanceName(),
             cfg.getSystemThreadPoolSize(),
@@ -350,7 +343,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
         WorkersRegistry workerRegistry = ctx.workersRegistry();
 
-        stripedExecSvc = createStripedExecutor(
+        stripedExecSvc = new IgniteStripedExecutor(
             cfg.getStripedPoolSize(),
             cfg.getIgniteInstanceName(),
             "sys",
@@ -372,7 +365,7 @@ public PoolProcessor(GridKernalContext ctx) {
         // not be needed.
         validateThreadPoolSize(cfg.getManagementThreadPoolSize(), "management");
 
-        mgmtExecSvc = createExecutorService(
+        mgmtExecSvc = new IgniteThreadPoolExecutor(
             "mgmt",
             cfg.getIgniteInstanceName(),
             cfg.getManagementThreadPoolSize(),
@@ -390,7 +383,7 @@ public PoolProcessor(GridKernalContext ctx) {
         // not be needed.
         validateThreadPoolSize(cfg.getPeerClassLoadingThreadPoolSize(), "peer class loading");
 
-        p2pExecSvc = createExecutorService(
+        p2pExecSvc = new IgniteThreadPoolExecutor(
             "p2p",
             cfg.getIgniteInstanceName(),
             cfg.getPeerClassLoadingThreadPoolSize(),
@@ -402,7 +395,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
         p2pExecSvc.allowCoreThreadTimeOut(true);
 
-        dataStreamerExecSvc = createStripedExecutor(
+        dataStreamerExecSvc = new IgniteStripedExecutor(
             cfg.getDataStreamerThreadPoolSize(),
             cfg.getIgniteInstanceName(),
             "data-streamer",
@@ -430,7 +423,7 @@ public PoolProcessor(GridKernalContext ctx) {
         if (cfg.getConnectorConfiguration() != null) {
             validateThreadPoolSize(cfg.getConnectorConfiguration().getThreadPoolSize(), "connector");
 
-            restExecSvc = createExecutorService(
+            restExecSvc = new IgniteThreadPoolExecutor(
                 "rest",
                 cfg.getIgniteInstanceName(),
                 cfg.getConnectorConfiguration().getThreadPoolSize(),
@@ -446,7 +439,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
         validateThreadPoolSize(cfg.getUtilityCacheThreadPoolSize(), "utility cache");
 
-        utilityCacheExecSvc = createExecutorService(
+        utilityCacheExecSvc = new IgniteThreadPoolExecutor(
             "utility",
             cfg.getIgniteInstanceName(),
             cfg.getUtilityCacheThreadPoolSize(),
@@ -458,7 +451,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
         utilityCacheExecSvc.allowCoreThreadTimeOut(true);
 
-        affExecSvc = createExecutorService(
+        affExecSvc = new IgniteThreadPoolExecutor(
             "aff",
             cfg.getIgniteInstanceName(),
             1,
@@ -473,7 +466,7 @@ public PoolProcessor(GridKernalContext ctx) {
         if (IgniteComponentType.INDEXING.inClassPath()) {
             int cpus = Runtime.getRuntime().availableProcessors();
 
-            idxExecSvc = createExecutorService(
+            idxExecSvc = new IgniteThreadPoolExecutor(
                 "idx",
                 cfg.getIgniteInstanceName(),
                 cpus,
@@ -490,7 +483,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
             validateThreadPoolSize(buildIdxThreadPoolSize, "build-idx");
 
-            buildIdxExecSvc = createExecutorService(
+            buildIdxExecSvc = new IgniteThreadPoolExecutor(
                 "build-idx-runner",
                 cfg.getIgniteInstanceName(),
                 buildIdxThreadPoolSize,
@@ -506,7 +499,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
         validateThreadPoolSize(cfg.getQueryThreadPoolSize(), "query");
 
-        qryExecSvc = createExecutorService(
+        qryExecSvc = new IgniteThreadPoolExecutor(
             "query",
             cfg.getIgniteInstanceName(),
             cfg.getQueryThreadPoolSize(),
@@ -520,7 +513,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
         addExecutorForStarvationDetection("query", qryExecSvc);
 
-        schemaExecSvc = createExecutorService(
+        schemaExecSvc = new IgniteThreadPoolExecutor(
             "schema",
             cfg.getIgniteInstanceName(),
             2,
@@ -534,7 +527,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
         validateThreadPoolSize(cfg.getRebalanceThreadPoolSize(), "rebalance");
 
-        rebalanceExecSvc = createExecutorService(
+        rebalanceExecSvc = new IgniteThreadPoolExecutor(
             "rebalance",
             cfg.getIgniteInstanceName(),
             cfg.getRebalanceThreadPoolSize(),
@@ -546,7 +539,7 @@ public PoolProcessor(GridKernalContext ctx) {
 
         rebalanceExecSvc.allowCoreThreadTimeOut(true);
 
-        snpExecSvc = createExecutorService(
+        snpExecSvc = new IgniteThreadPoolExecutor(
             SNAPSHOT_RUNNER_THREAD_PREFIX,
             cfg.getIgniteInstanceName(),
             cfg.getSnapshotThreadPoolSize(),
@@ -559,7 +552,7 @@ public PoolProcessor(GridKernalContext ctx) {
         snpExecSvc.allowCoreThreadTimeOut(true);
 
         if (CU.isPersistenceEnabled(ctx.config())) {
-            reencryptExecSvc = createExecutorService(
+            reencryptExecSvc = new IgniteThreadPoolExecutor(
                 "reencrypt",
                 ctx.igniteInstanceName(),
                 1,
@@ -584,7 +577,7 @@ public PoolProcessor(GridKernalContext ctx) {
                 oomeHnd);
         }
 
-        rebalanceStripedExecSvc = createStripedThreadPoolExecutor(
+        rebalanceStripedExecSvc = new IgniteStripedThreadPoolExecutor(
             cfg.getRebalanceThreadPoolSize(),
             cfg.getIgniteInstanceName(),
             "rebalance-striped",
@@ -598,7 +591,7 @@ public PoolProcessor(GridKernalContext ctx) {
             customExecs = new HashMap<>();
 
             for (ExecutorConfiguration execCfg : cfg.getExecutorConfiguration()) {
-                ThreadPoolExecutor exec = createExecutorService(
+                IgniteThreadPoolExecutor exec = new IgniteThreadPoolExecutor(
                     execCfg.getName(),
                     cfg.getIgniteInstanceName(),
                     execCfg.getSize(),
@@ -697,8 +690,8 @@ public void registerMetrics() {
                     String name = entry.getKey();
                     ExecutorService exec = entry.getValue();
 
-                    if (exec instanceof ThreadPoolExecutor) {
-                        ThreadPoolExecutor exec0 = (ThreadPoolExecutor)exec;
+                    if (exec instanceof IgniteThreadPoolExecutor) {
+                        IgniteThreadPoolExecutor exec0 = (IgniteThreadPoolExecutor)exec;
 
                         checkPoolStarvation(name, exec0.getCompletedTaskCount(), exec0.getPoolSize(),
                             exec0.getActiveCount(), exec0.getQueue().isEmpty());
@@ -862,7 +855,7 @@ public IgniteStripedThreadPoolExecutor asyncCallbackPool() {
      * @return Thread pool implementation to be used in grid to process job execution
      *      requests and user messages sent to the node.
      */
-    public ExecutorService getExecutorService() {
+    public IgniteThreadPoolExecutor getExecutorService() {
         return execSvc;
     }
 
@@ -871,7 +864,7 @@ public ExecutorService getExecutorService() {
      *
      * @return Thread pool implementation to be used in grid for service proxy invocations.
      */
-    public ExecutorService getServiceExecutorService() {
+    public IgniteThreadPoolExecutor getServiceExecutorService() {
         return svcExecSvc;
     }
 
@@ -880,7 +873,7 @@ public ExecutorService getServiceExecutorService() {
      *
      * @return Thread pool implementation to be used in grid for internal system messages.
      */
-    public ExecutorService getSystemExecutorService() {
+    public IgniteThreadPoolExecutor getSystemExecutorService() {
         return sysExecSvc;
     }
 
@@ -901,7 +894,7 @@ public IgniteStripedExecutor getStripedExecutorService() {
      * @return Thread pool implementation to be used in grid for internal and Visor
      *      jobs processing.
      */
-    public ExecutorService getManagementExecutorService() {
+    public IgniteThreadPoolExecutor getManagementExecutorService() {
         return mgmtExecSvc;
     }
 
@@ -909,7 +902,7 @@ public ExecutorService getManagementExecutorService() {
      * @return Thread pool implementation to be used for peer class loading
      *      requests handling.
      */
-    public ExecutorService getPeerClassLoadingExecutorService() {
+    public IgniteThreadPoolExecutor getPeerClassLoadingExecutorService() {
         return p2pExecSvc;
     }
 
@@ -929,7 +922,7 @@ public IgniteStripedExecutor getDataStreamerExecutorService() {
      * @return Thread pool implementation to be used for processing of client
      *      messages.
      */
-    public ExecutorService getRestExecutorService() {
+    public IgniteThreadPoolExecutor getRestExecutorService() {
         return restExecSvc;
     }
 
@@ -938,7 +931,7 @@ public ExecutorService getRestExecutorService() {
      *
      * @return Affinity executor service.
      */
-    public ExecutorService getAffinityExecutorService() {
+    public IgniteThreadPoolExecutor getAffinityExecutorService() {
         return affExecSvc;
     }
 
@@ -947,7 +940,7 @@ public ExecutorService getAffinityExecutorService() {
      *
      * @return Indexing executor service.
      */
-    @Nullable public ExecutorService getIndexingExecutorService() {
+    @Nullable public IgniteThreadPoolExecutor getIndexingExecutorService() {
         return idxExecSvc;
     }
 
@@ -956,7 +949,7 @@ public ExecutorService getAffinityExecutorService() {
      *
      * @return Thread pool implementation to be used in grid for query messages.
      */
-    public ExecutorService getQueryExecutorService() {
+    public IgniteThreadPoolExecutor getQueryExecutorService() {
         return qryExecSvc;
     }
 
@@ -974,7 +967,7 @@ public ExecutorService getQueryExecutorService() {
      *
      * @return Executor service that is in charge of processing schema change messages.
      */
-    public ExecutorService getSchemaExecutorService() {
+    public IgniteThreadPoolExecutor getSchemaExecutorService() {
         return schemaExecSvc;
     }
 
@@ -983,14 +976,14 @@ public ExecutorService getSchemaExecutorService() {
      *
      * @return Executor service that is in charge of processing rebalance messages.
      */
-    public ExecutorService getRebalanceExecutorService() {
+    public IgniteThreadPoolExecutor getRebalanceExecutorService() {
         return rebalanceExecSvc;
     }
 
     /**
      * @return Executor service that is used for processing snapshot tasks (taking, sending, restoring).
      */
-    public ExecutorService getSnapshotExecutorService() {
+    public IgniteThreadPoolExecutor getSnapshotExecutorService() {
         return snpExecSvc;
     }
 
@@ -999,7 +992,7 @@ public ExecutorService getSnapshotExecutorService() {
      *
      * @return Executor service for thin clients.
      */
-    public ExecutorService getThinClientExecutorService() {
+    public IgniteThreadPoolExecutor getThinClientExecutorService() {
         return thinClientExec;
     }
 
@@ -1017,14 +1010,14 @@ public IgniteStripedThreadPoolExecutor getStripedRebalanceExecutorService() {
      *
      * @return Thread pool for create/rebuild indexes.
      */
-    public ExecutorService buildIndexExecutorService() {
+    public IgniteThreadPoolExecutor buildIndexExecutorService() {
         return buildIdxExecSvc;
     }
 
     /**
      * @return Executor to perform a data pages scanning during cache group re-encryption.
      */
-    public ExecutorService getReencryptionExecutorService() {
+    public IgniteThreadPoolExecutor getReencryptionExecutorService() {
         return reencryptExecSvc;
     }
 
@@ -1160,7 +1153,7 @@ private void stopExecutors0(IgniteLogger log) {
         reencryptExecSvc = null;
 
         if (!F.isEmpty(customExecs)) {
-            for (ThreadPoolExecutor exec : customExecs.values())
+            for (IgniteThreadPoolExecutor exec : customExecs.values())
                 U.shutdownNow(getClass(), exec, log);
 
             customExecs = null;
@@ -1205,95 +1198,4 @@ private static void validateCustomExecutorsConfiguration(ExecutorConfiguration[]
                     ", size=" + cfg.getSize() + ']');
         }
     }
-
-    /** Creates instance {@link IgniteStripedThreadPoolExecutor} with a notion of whether {@link IgniteSecurity} is enabled. */
-    private IgniteStripedThreadPoolExecutor createStripedThreadPoolExecutor(
-        int concurrentLvl,
-        String igniteInstanceName,
-        String threadNamePrefix,
-        UncaughtExceptionHandler eHnd,
-        boolean allowCoreThreadTimeOut,
-        long keepAliveTime
-    ) {
-        return ctx.security().enabled()
-            ? new OperationContextAwareStripedThreadPoolExecutor(
-                concurrentLvl,
-                igniteInstanceName,
-                threadNamePrefix,
-                eHnd,
-                allowCoreThreadTimeOut,
-                keepAliveTime)
-            : new IgniteStripedThreadPoolExecutor(
-                concurrentLvl,
-                igniteInstanceName,
-                threadNamePrefix,
-                eHnd,
-                allowCoreThreadTimeOut,
-                keepAliveTime);
-    }
-
-    /** Creates instance {@link IgniteStripedExecutor} with a notion of whether {@link IgniteSecurity} is enabled. */
-    private IgniteStripedExecutor createStripedExecutor(
-        int cnt,
-        String igniteInstanceName,
-        String poolName,
-        final IgniteLogger log,
-        IgniteInClosure<Throwable> errHnd,
-        boolean stealTasks,
-        GridWorkerListener gridWorkerLsnr,
-        long failureDetectionTimeout
-    ) {
-        return ctx.security().enabled()
-            ? new OperationContextAwareStripedExecutor(
-                cnt,
-                igniteInstanceName,
-                poolName,
-                log,
-                errHnd,
-                stealTasks,
-                gridWorkerLsnr,
-                failureDetectionTimeout)
-            : new IgniteStripedExecutor(
-                cnt,
-                igniteInstanceName,
-                poolName,
-                log,
-                errHnd,
-                stealTasks,
-                gridWorkerLsnr,
-                failureDetectionTimeout
-        );
-    }
-
-    /** Creates instance {@link IgniteThreadPoolExecutor} with a notion of whether {@link IgniteSecurity} is enabled. */
-    private IgniteThreadPoolExecutor createExecutorService(
-        String threadNamePrefix,
-        String igniteInstanceName,
-        int corePoolSize,
-        int maxPoolSize,
-        long keepAliveTime,
-        BlockingQueue<Runnable> workQ,
-        byte plc,
-        UncaughtExceptionHandler eHnd
-    ) {
-        return ctx.security().enabled()
-            ? new OperationContextAwareThreadPoolExecutor(
-                threadNamePrefix,
-                igniteInstanceName,
-                corePoolSize,
-                maxPoolSize,
-                keepAliveTime,
-                workQ,
-                plc,
-                eHnd)
-            : new IgniteThreadPoolExecutor(
-                threadNamePrefix,
-                igniteInstanceName,
-                corePoolSize,
-                maxPoolSize,
-                keepAliveTime,
-                workQ,
-                plc,
-                eHnd);
-    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java
index 1c470a8cae2b9..ed9153b4969be 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java
@@ -37,8 +37,6 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Supplier;
@@ -72,7 +70,6 @@
 import org.apache.ignite.internal.processors.platform.services.PlatformServiceConfiguration;
 import org.apache.ignite.internal.processors.security.SecurityContext;
 import org.apache.ignite.internal.systemview.ServiceViewWalker;
-import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.internal.thread.OomExceptionHandler;
 import org.apache.ignite.internal.thread.context.Scope;
 import org.apache.ignite.internal.util.future.GridCompoundFuture;
@@ -110,6 +107,7 @@
 import static org.apache.ignite.internal.GridComponent.DiscoveryDataExchangeType.SERVICE_PROC;
 import static org.apache.ignite.internal.processors.metric.impl.MetricUtils.metricName;
 import static org.apache.ignite.internal.processors.security.SecurityUtils.nodeSecurityContext;
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newSingleThreadExecutor;
 import static org.apache.ignite.internal.util.IgniteUtils.allInterfaces;
 import static org.apache.ignite.plugin.security.SecurityPermission.SERVICE_DEPLOY;
 
@@ -124,7 +122,6 @@
  * @see ServiceDeploymentActions
  * @see ServiceChangeBatchRequest
  */
-@SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
 public class IgniteServiceProcessor extends GridProcessorAdapter implements IgniteChangeGlobalStateSupport {
     /** */
     public static final String SVCS_VIEW = "services";
@@ -198,10 +195,6 @@ public class IgniteServiceProcessor extends GridProcessorAdapter implements Igni
     /** Undeployment futures. */
     private final ConcurrentMap<IgniteUuid, GridFutureAdapter<?>> undepFuts = new ConcurrentHashMap<>();
 
-    /** Thread factory. */
-    private final ThreadFactory threadFactory = new IgniteThreadFactory(ctx.igniteInstanceName(), "service",
-        new OomExceptionHandler(ctx));
-
     /** Marshaller for serialization/deserialization of service's instance. */
     private final Marshaller marsh;
 
@@ -1305,7 +1298,7 @@ else if (ctxs.size() < assignCnt) {
                         UUID.randomUUID(),
                         cacheName,
                         affKey,
-                        Executors.newSingleThreadExecutor(threadFactory),
+                        newSingleThreadExecutor("service", ctx.igniteInstanceName(), new OomExceptionHandler(ctx)),
                         cfg.isStatisticsEnabled());
 
                     ctxs.add(srvcCtx);
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteForkJoinPool.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteForkJoinPool.java
new file mode 100644
index 0000000000000..00ba22b59e7d7
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteForkJoinPool.java
@@ -0,0 +1,88 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.thread.pool;
+
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.ForkJoinWorkerThread;
+import org.apache.ignite.internal.thread.context.OperationContext;
+import org.apache.ignite.internal.thread.context.concurrent.OperationContextAwareExecutorService;
+import org.apache.ignite.internal.thread.context.concurrent.OperationContextAwareScheduledExecutorService;
+import org.apache.ignite.thread.IgniteThread;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Ignite specific wrapper over {@link ForkJoinPool} that supports {@link OperationContext} propagation and customizes
+ * pool's thread factory using Ignite instance info.
+ *
+ * @see OperationContext
+ * @see OperationContextAwareScheduledExecutorService
+ */
+public class IgniteForkJoinPool extends OperationContextAwareExecutorService<ForkJoinPool> {
+    /** */
+    private static final IgniteForkJoinPool COMMON = new IgniteForkJoinPool(ForkJoinPool.commonPool());
+
+    /** */
+    public IgniteForkJoinPool(
+        String threadNamePrefix,
+        @Nullable String igniteInstanceName,
+        int parallelism,
+        @Nullable Thread.UncaughtExceptionHandler handler,
+        boolean asyncMode
+    ) {
+        this(new ForkJoinPool(
+            parallelism,
+            new IgniteForkJoinWorkerThreadFactory(threadNamePrefix, igniteInstanceName),
+            handler,
+            asyncMode
+        ));
+    }
+
+    /** */
+    private IgniteForkJoinPool(ForkJoinPool delegate) {
+        super(delegate);
+    }
+
+    /** */
+    public static IgniteForkJoinPool commonPool() {
+        return COMMON;
+    }
+
+    /** */
+    private static final class IgniteForkJoinWorkerThreadFactory implements ForkJoinPool.ForkJoinWorkerThreadFactory {
+        /** */
+        private final String threadName;
+
+        /** */
+        private final String igniteInstanceName;
+
+        /** */
+        private IgniteForkJoinWorkerThreadFactory(String threadName, String igniteInstanceName) {
+            this.threadName = threadName;
+            this.igniteInstanceName = igniteInstanceName;
+        }
+
+        /** {@inheritDoc} */
+        @Override public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
+            ForkJoinWorkerThread worker = ForkJoinPool.defaultForkJoinWorkerThreadFactory.newThread(pool);
+
+            worker.setName(IgniteThread.createName(worker.getPoolIndex(), threadName, igniteInstanceName));
+
+            return worker;
+        }
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteScheduledThreadPoolExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteScheduledThreadPoolExecutor.java
new file mode 100644
index 0000000000000..97029b741f263
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteScheduledThreadPoolExecutor.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.thread.pool;
+
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import org.apache.ignite.internal.thread.IgniteThreadFactory;
+import org.apache.ignite.internal.thread.context.OperationContext;
+import org.apache.ignite.internal.thread.context.concurrent.OperationContextAwareScheduledExecutorService;
+import org.jetbrains.annotations.Nullable;
+
+import static org.apache.ignite.internal.managers.communication.GridIoPolicy.UNDEFINED;
+
+/**
+ * Ignite specific wrapper over {@link ScheduledThreadPoolExecutor} that supports {@link OperationContext} propagation
+ * and automatically uses custom Ignite {@link IgniteThreadFactory}.
+ *
+ * @see OperationContext
+ * @see OperationContextAwareScheduledExecutorService
+ */
+public class IgniteScheduledThreadPoolExecutor extends OperationContextAwareScheduledExecutorService {
+    /**
+     * @param threadNamePrefix Pool thread name prefix.
+     * @param igniteInstanceName Ignite instance name.
+     * @param poolSize Pool size.
+     */
+    public IgniteScheduledThreadPoolExecutor(String threadNamePrefix, String igniteInstanceName, int poolSize) {
+        super(new ScheduledThreadPoolExecutor(
+            poolSize,
+            new IgniteThreadFactory(igniteInstanceName, threadNamePrefix, UNDEFINED, null))
+        );
+    }
+
+    /**
+     * @param threadNamePrefix Pool thread name prefix.
+     * @param igniteInstanceName Ignite instance name.
+     * @return Thread pool instance.
+     */
+    public static ScheduledExecutorService newSingleThreadScheduledExecutor(String threadNamePrefix, @Nullable String igniteInstanceName) {
+        return new IgniteScheduledThreadPoolExecutor(threadNamePrefix, igniteInstanceName, 1);
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteStripedExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteStripedExecutor.java
index 36be6ad4db3c6..2a89cbfab2254 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteStripedExecutor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteStripedExecutor.java
@@ -59,6 +59,7 @@
 import static org.apache.ignite.internal.processors.pool.PoolProcessor.TASK_EXEC_TIME;
 import static org.apache.ignite.internal.processors.pool.PoolProcessor.TASK_EXEC_TIME_DESC;
 import static org.apache.ignite.internal.processors.pool.PoolProcessor.TASK_EXEC_TIME_HISTOGRAM_BUCKETS;
+import static org.apache.ignite.internal.thread.context.function.OperationContextAwareRunnable.wrapIfContextNotEmpty;
 
 /**
  * Striped executor.
@@ -830,7 +831,7 @@ private static class StripeConcurrentQueue extends Stripe {
 
         /** {@inheritDoc} */
         @Override void execute(Runnable cmd) {
-            queue.add(cmd);
+            queue.add(wrapIfContextNotEmpty(cmd));
 
             if (parked)
                 LockSupport.unpark(thread);
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteThreadPoolExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteThreadPoolExecutor.java
index 8aa55d2aa3e9f..4fda88352098d 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteThreadPoolExecutor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/IgniteThreadPoolExecutor.java
@@ -20,6 +20,9 @@
 import java.lang.Thread.UncaughtExceptionHandler;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.SynchronousQueue;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
@@ -28,11 +31,14 @@
 import org.apache.ignite.internal.processors.metric.impl.HistogramMetricImpl;
 import org.apache.ignite.internal.processors.pool.MetricsAwareExecutorService;
 import org.apache.ignite.internal.thread.IgniteThreadFactory;
+import org.apache.ignite.internal.thread.context.concurrent.OperationContextAwareExecutorService;
 import org.apache.ignite.internal.util.GridMutableLong;
 import org.apache.ignite.internal.util.tostring.GridToStringExclude;
 import org.apache.ignite.internal.util.typedef.internal.U;
 import org.jetbrains.annotations.Nullable;
 
+import static java.lang.Integer.MAX_VALUE;
+import static java.util.concurrent.TimeUnit.MINUTES;
 import static org.apache.ignite.internal.processors.metric.impl.MetricUtils.metricName;
 import static org.apache.ignite.internal.processors.pool.PoolProcessor.ACTIVE_COUNT_DESC;
 import static org.apache.ignite.internal.processors.pool.PoolProcessor.COMPLETED_TASK_DESC;
@@ -55,7 +61,8 @@
 /**
  * An {@link ExecutorService} that executes submitted tasks using pooled grid threads.
  */
-public class IgniteThreadPoolExecutor extends ThreadPoolExecutor implements MetricsAwareExecutorService {
+public class IgniteThreadPoolExecutor extends OperationContextAwareExecutorService<ThreadPoolExecutor>
+    implements MetricsAwareExecutorService {
     /** Thread local task start time. */
     @GridToStringExclude
     private final ThreadLocal<GridMutableLong> taskStartTime = ThreadLocal.withInitial(() -> new GridMutableLong(0));
@@ -85,15 +92,18 @@ public IgniteThreadPoolExecutor(
         int corePoolSize,
         int maxPoolSize,
         long keepAliveTime,
-        BlockingQueue<Runnable> workQ) {
-        this(threadNamePrefix,
+        BlockingQueue<Runnable> workQ
+    ) {
+        this(
+            threadNamePrefix,
             igniteInstanceName,
             corePoolSize,
             maxPoolSize,
             keepAliveTime,
             workQ,
             GridIoPolicy.UNDEFINED,
-            null);
+            null
+        );
     }
 
     /**
@@ -121,7 +131,8 @@ public IgniteThreadPoolExecutor(
         long keepAliveTime,
         BlockingQueue<Runnable> workQ,
         byte plc,
-        UncaughtExceptionHandler eHnd) {
+        UncaughtExceptionHandler eHnd
+    ) {
         this(
             corePoolSize,
             maxPoolSize,
@@ -150,7 +161,8 @@ public IgniteThreadPoolExecutor(
         int maxPoolSize,
         long keepAliveTime,
         BlockingQueue<Runnable> workQ,
-        ThreadFactory threadFactory) {
+        ThreadFactory threadFactory
+    ) {
         this(
             corePoolSize,
             maxPoolSize,
@@ -182,36 +194,111 @@ protected IgniteThreadPoolExecutor(
         long keepAliveTime,
         BlockingQueue<Runnable> workQ,
         ThreadFactory threadFactory,
-        @Nullable HistogramMetricImpl execTime) {
-        super(
+        @Nullable HistogramMetricImpl execTime
+    ) {
+        delegate = new ThreadPoolExecutor(
             corePoolSize,
             maxPoolSize,
             keepAliveTime,
             TimeUnit.MILLISECONDS,
             workQ,
             threadFactory,
-            new AbortPolicy()
-        );
+            new ThreadPoolExecutor.AbortPolicy()
+        ) {
+            @Override protected void beforeExecute(Thread t, Runnable r) {
+                IgniteThreadPoolExecutor.this.beforeExecute(t, r);
+            }
+
+            @Override protected void afterExecute(Runnable r, Throwable t) {
+                IgniteThreadPoolExecutor.this.afterExecute(r, t);
+            }
+        };
 
         this.execTime = execTime != null
             ? execTime
             : new HistogramMetricImpl(TASK_EXEC_TIME, TASK_EXEC_TIME_DESC, TASK_EXEC_TIME_HISTOGRAM_BUCKETS);
     }
 
-    /** {@inheritDoc} */
-    @Override protected void beforeExecute(Thread t, Runnable r) {
-        super.beforeExecute(t, r);
+    /** */
+    public boolean isTerminating() {
+        return delegate.isTerminating();
+    }
+
+    /** */
+    public ThreadFactory getThreadFactory() {
+        return delegate.getThreadFactory();
+    }
+
+    /** */
+    public RejectedExecutionHandler getRejectedExecutionHandler() {
+        return delegate.getRejectedExecutionHandler();
+    }
+
+    /** */
+    public int getCorePoolSize() {
+        return delegate.getCorePoolSize();
+    }
+
+    /** */
+    public int getMaximumPoolSize() {
+        return delegate.getMaximumPoolSize();
+    }
+
+    /** */
+    public long getKeepAliveTime(TimeUnit unit) {
+        return delegate.getKeepAliveTime(unit);
+    }
+
+    /** */
+    public BlockingQueue<Runnable> getQueue() {
+        return delegate.getQueue();
+    }
+
+    /** */
+    public int getPoolSize() {
+        return delegate.getPoolSize();
+    }
+
+    /** */
+    public int getActiveCount() {
+        return delegate.getActiveCount();
+    }
+
+    /** */
+    public int getLargestPoolSize() {
+        return delegate.getLargestPoolSize();
+    }
+
+    /** */
+    public long getTaskCount() {
+        return delegate.getTaskCount();
+    }
+
+    /** */
+    public long getCompletedTaskCount() {
+        return delegate.getCompletedTaskCount();
+    }
 
+    /** */
+    public void allowCoreThreadTimeOut(boolean value) {
+        delegate.allowCoreThreadTimeOut(value);
+    }
+
+    /** */
+    public int prestartAllCoreThreads() {
+        return delegate.prestartAllCoreThreads();
+    }
+
+    /** */
+    protected void beforeExecute(Thread t, Runnable r) {
         taskStartTime.get().set(U.currentTimeMillis());
     }
 
-    /** {@inheritDoc} */
-    @Override protected void afterExecute(Runnable r, Throwable t) {
+    /** */
+    protected void afterExecute(Runnable r, Throwable t) {
         GridMutableLong val = taskStartTime.get();
 
         execTime.value(U.currentTimeMillis() - val.get());
-
-        super.afterExecute(r, t);
     }
 
     /** {@inheritDoc} */
@@ -246,4 +333,62 @@ protected IgniteThreadPoolExecutor(
     protected void executionTimeMetric(HistogramMetricImpl execTime) {
         this.execTime = execTime;
     }
+
+    /**
+     * @param threadNamePrefix Pool thread name prefix.
+     * @param igniteInstanceName Ignite instance name.
+     * @return Thread pool instance.
+     */
+    public static IgniteThreadPoolExecutor newSingleThreadExecutor(String threadNamePrefix, String igniteInstanceName) {
+        return newSingleThreadExecutor(threadNamePrefix, igniteInstanceName, null);
+    }
+
+    /**
+     * @param threadNamePrefix Pool thread name prefix.
+     * @param igniteInstanceName Ignite instance name.
+     * @param errHandler Error handler.
+     * @return Thread pool instance.
+     */
+    public static IgniteThreadPoolExecutor newSingleThreadExecutor(
+        String threadNamePrefix,
+        String igniteInstanceName,
+        UncaughtExceptionHandler errHandler
+    ) {
+        return new IgniteThreadPoolExecutor(
+            threadNamePrefix,
+            igniteInstanceName,
+            1,
+            1,
+            0,
+            new LinkedBlockingQueue<>(),
+            GridIoPolicy.UNDEFINED,
+            errHandler
+        );
+    }
+
+    /**
+     * @param threadNamePrefix Pool thread name prefix.
+     * @param igniteInstanceName Ignite instance name.
+     * @param poolSize Pool size.
+     * @return Thread pool instance.
+     */
+    public static IgniteThreadPoolExecutor newFixedThreadPool(String threadNamePrefix, String igniteInstanceName, int poolSize) {
+        return new IgniteThreadPoolExecutor(threadNamePrefix, igniteInstanceName, poolSize, poolSize, 0, new LinkedBlockingQueue<>());
+    }
+
+    /**
+     * @param threadNamePrefix Pool thread name prefix.
+     * @param igniteInstanceName Ignite instance name.
+     * @return Thread pool instance.
+     */
+    public static IgniteThreadPoolExecutor newCachedThreadPool(String threadNamePrefix, String igniteInstanceName) {
+        return new IgniteThreadPoolExecutor(
+            threadNamePrefix,
+            igniteInstanceName,
+            0,
+            MAX_VALUE,
+            MINUTES.toMillis(60),
+            new SynchronousQueue<>()
+        );
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/OperationContextAwareStripedExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/OperationContextAwareStripedExecutor.java
deleted file mode 100644
index 312fc5ef247c4..0000000000000
--- a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/OperationContextAwareStripedExecutor.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.internal.thread.pool;
-
-import org.apache.ignite.IgniteLogger;
-import org.apache.ignite.internal.thread.context.function.OperationContextAwareRunnable;
-import org.apache.ignite.internal.util.worker.GridWorkerListener;
-import org.apache.ignite.lang.IgniteInClosure;
-import org.jetbrains.annotations.NotNull;
-
-/** */
-public class OperationContextAwareStripedExecutor extends IgniteStripedExecutor {
-    /** */
-    public OperationContextAwareStripedExecutor(
-        int cnt,
-        String igniteInstanceName,
-        String poolName,
-        IgniteLogger log,
-        IgniteInClosure<Throwable> errHnd,
-        boolean stealTasks,
-        GridWorkerListener gridWorkerLsnr,
-        long failureDetectionTimeout
-    ) {
-        super(cnt, igniteInstanceName, poolName, log, errHnd, stealTasks, gridWorkerLsnr, failureDetectionTimeout);
-    }
-
-    /** {@inheritDoc} */
-    @Override public void execute(@NotNull Runnable cmd) {
-        super.execute(OperationContextAwareRunnable.wrapIfContextNotEmpty(cmd));
-    }
-
-    /** {@inheritDoc} */
-    @Override public void execute(int idx, Runnable cmd) {
-        super.execute(idx, OperationContextAwareRunnable.wrapIfContextNotEmpty(cmd));
-    }
-}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/OperationContextAwareThreadPoolExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/OperationContextAwareThreadPoolExecutor.java
deleted file mode 100644
index fd31c87a0e299..0000000000000
--- a/modules/core/src/main/java/org/apache/ignite/internal/thread/pool/OperationContextAwareThreadPoolExecutor.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.internal.thread.pool;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import org.apache.ignite.internal.thread.context.function.OperationContextAwareCallable;
-import org.apache.ignite.internal.thread.context.function.OperationContextAwareRunnable;
-import org.jetbrains.annotations.NotNull;
-
-/** */
-public class OperationContextAwareThreadPoolExecutor extends IgniteThreadPoolExecutor {
-    /** */
-    public OperationContextAwareThreadPoolExecutor(
-        String threadNamePrefix,
-        String igniteInstanceName,
-        int corePoolSize,
-        int maxPoolSize,
-        long keepAliveTime,
-        BlockingQueue<Runnable> workQ,
-        byte plc,
-        Thread.UncaughtExceptionHandler eHnd
-    ) {
-        super(threadNamePrefix, igniteInstanceName, corePoolSize, maxPoolSize, keepAliveTime, workQ, plc, eHnd);
-    }
-
-    /** {@inheritDoc} */
-    @NotNull @Override public <T> Future<T> submit(@NotNull Callable<T> task) {
-        return super.submit(OperationContextAwareCallable.wrapIfContextNotEmpty(task));
-    }
-
-    /** {@inheritDoc} */
-    @NotNull @Override public <T> Future<T> submit(@NotNull Runnable task, T res) {
-        return super.submit(OperationContextAwareRunnable.wrapIfContextNotEmpty(task), res);
-    }
-
-    /** {@inheritDoc} */
-    @NotNull @Override public Future<?> submit(@NotNull Runnable task) {
-        return super.submit(OperationContextAwareRunnable.wrapIfContextNotEmpty(task));
-    }
-
-    /** {@inheritDoc} */
-    @NotNull @Override public <T> List<Future<T>> invokeAll(@NotNull Collection<? extends Callable<T>> tasks) throws InterruptedException {
-        return super.invokeAll(OperationContextAwareCallable.wrapIfContextNotEmpty(tasks));
-    }
-
-    /** {@inheritDoc} */
-    @NotNull @Override public <T> List<Future<T>> invokeAll(
-        @NotNull Collection<? extends Callable<T>> tasks,
-        long timeout,
-        @NotNull TimeUnit unit
-    ) throws InterruptedException {
-        return super.invokeAll(OperationContextAwareCallable.wrapIfContextNotEmpty(tasks), timeout, unit);
-    }
-
-    /** {@inheritDoc} */
-    @NotNull @Override public <T> T invokeAny(@NotNull Collection<? extends Callable<T>> tasks)
-        throws InterruptedException, ExecutionException {
-        return super.invokeAny(OperationContextAwareCallable.wrapIfContextNotEmpty(tasks));
-    }
-
-    /** {@inheritDoc} */
-    @Override public <T> T invokeAny(@NotNull Collection<? extends Callable<T>> tasks,
-        long timeout, @NotNull TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
-        return super.invokeAny(OperationContextAwareCallable.wrapIfContextNotEmpty(tasks), timeout, unit);
-    }
-
-    /** {@inheritDoc} */
-    @Override public void execute(@NotNull Runnable cmd) {
-        super.execute(OperationContextAwareRunnable.wrapIfContextNotEmpty(cmd));
-    }
-}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java b/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java
index 9e82b3a9700e3..845d664f927a0 100755
--- a/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java
@@ -106,7 +106,6 @@
 import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
@@ -195,7 +194,6 @@
 import org.apache.ignite.internal.processors.cache.CacheObjectContext;
 import org.apache.ignite.internal.processors.cache.GridCacheSharedContext;
 import org.apache.ignite.internal.processors.cache.IgnitePeerToPeerClassLoadingException;
-import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.internal.transactions.IgniteTxHeuristicCheckedException;
 import org.apache.ignite.internal.transactions.IgniteTxOptimisticCheckedException;
 import org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException;
@@ -264,6 +262,7 @@
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_JVM_PID;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_MACS;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_OFFHEAP_SIZE;
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newFixedThreadPool;
 import static org.apache.ignite.internal.util.GridUnsafe.putObjectVolatile;
 import static org.apache.ignite.internal.util.GridUnsafe.staticFieldBase;
 import static org.apache.ignite.internal.util.GridUnsafe.staticFieldOffset;
@@ -1363,8 +1362,7 @@ public static List<InetAddress> filterReachable(Collection<InetAddress> addrs) {
 
         Collection<Future<?>> futs = new ArrayList<>(addrs.size());
 
-        ExecutorService executor = Executors.newFixedThreadPool(Math.min(10, addrs.size()),
-            new IgniteThreadFactory("utils", "reachable"));
+        ExecutorService executor = newFixedThreadPool("reachable", "utils", Math.min(10, addrs.size()));
 
         try {
             for (final InetAddress addr : addrs) {
diff --git a/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/ConnectionClientPool.java b/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/ConnectionClientPool.java
index 82720bc977409..6be1c684fc721 100644
--- a/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/ConnectionClientPool.java
+++ b/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/ConnectionClientPool.java
@@ -43,7 +43,6 @@
 import org.apache.ignite.internal.cluster.ClusterTopologyCheckedException;
 import org.apache.ignite.internal.processors.metric.GridMetricManager;
 import org.apache.ignite.internal.processors.metric.MetricRegistryImpl;
-import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.internal.util.GridConcurrentFactory;
 import org.apache.ignite.internal.util.future.GridFutureAdapter;
 import org.apache.ignite.internal.util.nio.GridCommunicationClient;
@@ -60,8 +59,8 @@
 import org.jetbrains.annotations.Nullable;
 
 import static java.util.Objects.nonNull;
-import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor;
 import static org.apache.ignite.internal.processors.metric.impl.MetricUtils.metricName;
+import static org.apache.ignite.internal.thread.pool.IgniteScheduledThreadPoolExecutor.newSingleThreadScheduledExecutor;
 import static org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi.DISABLED_CLIENT_PORT;
 import static org.apache.ignite.spi.communication.tcp.internal.CommunicationTcpUtils.nodeAddresses;
 import static org.apache.ignite.spi.communication.tcp.internal.CommunicationTcpUtils.usePairedConnections;
@@ -210,9 +209,7 @@ public ConnectionClientPool(
         this.metricsMgr = metricsMgr;
         this.nodeGetter = nodeGetter;
 
-        this.handshakeTimeoutExecutorService = newSingleThreadScheduledExecutor(
-            new IgniteThreadFactory(igniteInstanceName, "handshake-timeout-client")
-        );
+        this.handshakeTimeoutExecutorService = newSingleThreadScheduledExecutor("handshake-timeout-client", igniteInstanceName);
 
         metrics = new ConcurrentHashMap<>(64, 0.75f, Math.max(16, Runtime.getRuntime().availableProcessors()));
 
diff --git a/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/GridNioServerWrapper.java b/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/GridNioServerWrapper.java
index b8eee2efbc59a..99d310b5c03c6 100644
--- a/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/GridNioServerWrapper.java
+++ b/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/GridNioServerWrapper.java
@@ -57,7 +57,6 @@
 import org.apache.ignite.internal.managers.tracing.GridTracingManager;
 import org.apache.ignite.internal.processors.metric.GridMetricManager;
 import org.apache.ignite.internal.processors.tracing.Tracing;
-import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.internal.util.GridConcurrentFactory;
 import org.apache.ignite.internal.util.IgniteExceptionRegistry;
 import org.apache.ignite.internal.util.function.ThrowableBiFunction;
@@ -105,7 +104,7 @@
 import org.apache.ignite.spi.discovery.IgniteDiscoveryThread;
 import org.jetbrains.annotations.Nullable;
 
-import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor;
+import static org.apache.ignite.internal.thread.pool.IgniteScheduledThreadPoolExecutor.newSingleThreadScheduledExecutor;
 import static org.apache.ignite.internal.util.nio.GridNioSessionMetaKey.SSL_META;
 import static org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi.COMMUNICATION_METRICS_GROUP_NAME;
 import static org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi.CONN_IDX_META;
@@ -300,9 +299,7 @@ public GridNioServerWrapper(
         };
         this.tcpHandshakeExecutor = tcpHandshakeExecutor;
 
-        this.handshakeTimeoutExecutorService = newSingleThreadScheduledExecutor(
-            new IgniteThreadFactory(igniteInstanceName, "handshake-timeout-nio")
-        );
+        this.handshakeTimeoutExecutorService = newSingleThreadScheduledExecutor("handshake-timeout-nio", igniteInstanceName);
     }
 
     /**
diff --git a/modules/core/src/main/java/org/apache/ignite/spi/discovery/isolated/IsolatedDiscoverySpi.java b/modules/core/src/main/java/org/apache/ignite/spi/discovery/isolated/IsolatedDiscoverySpi.java
index 1e0d02019fbb8..63800c3d19b8c 100644
--- a/modules/core/src/main/java/org/apache/ignite/spi/discovery/isolated/IsolatedDiscoverySpi.java
+++ b/modules/core/src/main/java/org/apache/ignite/spi/discovery/isolated/IsolatedDiscoverySpi.java
@@ -22,7 +22,6 @@
 import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import org.apache.ignite.Ignite;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.IgniteException;
@@ -31,6 +30,7 @@
 import org.apache.ignite.internal.IgniteEx;
 import org.apache.ignite.internal.IgniteKernal;
 import org.apache.ignite.internal.managers.discovery.IgniteDiscoverySpi;
+import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.lang.IgniteFuture;
 import org.apache.ignite.lang.IgniteProductVersion;
 import org.apache.ignite.marshaller.Marshaller;
@@ -82,7 +82,7 @@ public class IsolatedDiscoverySpi extends IgniteSpiAdapter implements IgniteDisc
     private DiscoverySpiListener lsnr;
 
     /** */
-    private ExecutorService exec = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+    private ExecutorService exec;
 
     /** */
     private DiscoverySpiNodeAuthenticator nodeAuth;
@@ -201,6 +201,12 @@ public class IsolatedDiscoverySpi extends IgniteSpiAdapter implements IgniteDisc
 
     /** {@inheritDoc} */
     @Override public void spiStart(@Nullable String igniteInstanceName) throws IgniteSpiException {
+        exec = IgniteThreadPoolExecutor.newFixedThreadPool(
+            "isolated-discovery-worker",
+            igniteInstanceName,
+            Runtime.getRuntime().availableProcessors()
+        );
+
         if (nodeAuth != null) {
             try {
                 SecurityCredentials locSecCred = (SecurityCredentials)locNode.attributes().get(ATTR_SECURITY_CREDENTIALS);
@@ -231,7 +237,8 @@ public class IsolatedDiscoverySpi extends IgniteSpiAdapter implements IgniteDisc
 
     /** {@inheritDoc} */
     @Override public void spiStop() throws IgniteSpiException {
-        exec.shutdownNow();
+        if (exec != null)
+            exec.shutdownNow();
     }
 
     /** {@inheritDoc} */
diff --git a/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ClientImpl.java b/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ClientImpl.java
index 0fce9fac5bb8d..f7812b0ebb8be 100644
--- a/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ClientImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ClientImpl.java
@@ -43,7 +43,6 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingDeque;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ThreadLocalRandom;
@@ -71,7 +70,6 @@
 import org.apache.ignite.internal.processors.tracing.messages.SpanContainer;
 import org.apache.ignite.internal.processors.tracing.messages.TraceableMessage;
 import org.apache.ignite.internal.processors.tracing.messages.TraceableMessagesTable;
-import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.internal.util.future.GridFutureAdapter;
 import org.apache.ignite.internal.util.tostring.GridToStringExclude;
 import org.apache.ignite.internal.util.typedef.F;
@@ -131,6 +129,7 @@
 import static org.apache.ignite.events.EventType.EVT_NODE_SEGMENTED;
 import static org.apache.ignite.failure.FailureType.CRITICAL_ERROR;
 import static org.apache.ignite.internal.events.DiscoveryCustomEvent.EVT_DISCOVERY_CUSTOM_EVT;
+import static org.apache.ignite.internal.thread.pool.IgniteScheduledThreadPoolExecutor.newSingleThreadScheduledExecutor;
 import static org.apache.ignite.spi.discovery.tcp.ClientImpl.State.CONNECTED;
 import static org.apache.ignite.spi.discovery.tcp.ClientImpl.State.DISCONNECTED;
 import static org.apache.ignite.spi.discovery.tcp.ClientImpl.State.SEGMENTED;
@@ -216,8 +215,7 @@ class ClientImpl extends TcpDiscoveryImpl {
         String instanceName = adapter.ignite() == null || adapter.ignite().name() == null
             ? "client-node" : adapter.ignite().name();
 
-        executorSrvc = Executors.newSingleThreadScheduledExecutor(
-            new IgniteThreadFactory(instanceName, "tcp-discovery-exec"));
+        executorSrvc = newSingleThreadScheduledExecutor("tcp-discovery-exec", instanceName);
     }
 
     /** {@inheritDoc} */
diff --git a/modules/core/src/main/java/org/apache/ignite/startup/BasicWarmupClosure.java b/modules/core/src/main/java/org/apache/ignite/startup/BasicWarmupClosure.java
index eabaefde3ba5a..d02c00a132ea7 100644
--- a/modules/core/src/main/java/org/apache/ignite/startup/BasicWarmupClosure.java
+++ b/modules/core/src/main/java/org/apache/ignite/startup/BasicWarmupClosure.java
@@ -24,7 +24,6 @@
 import java.util.Objects;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.ThreadLocalRandom;
 import org.apache.ignite.Ignite;
@@ -49,10 +48,15 @@
 import org.apache.ignite.spi.discovery.tcp.ipfinder.TcpDiscoveryIpFinder;
 import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder;
 
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newFixedThreadPool;
+
 /**
  * Basic warm-up closure which warm-ups cache operations.
  */
 public class BasicWarmupClosure implements IgniteInClosure<IgniteConfiguration> {
+    /** */
+    private static final String WARM_UP_THREAD_PREFIX = "warm-up-worker";
+
     /** */
     private static final long serialVersionUID = 9175346848249957458L;
 
@@ -255,7 +259,7 @@ public void setDiscoveryPort(int discoveryPort) {
     private void doWarmup(Iterable<Ignite> grids) throws Exception {
         Ignite first = F.first(grids);
 
-        ExecutorService svc = Executors.newFixedThreadPool(threadCnt);
+        ExecutorService svc = newFixedThreadPool(WARM_UP_THREAD_PREFIX, first.name(), threadCnt);
 
         try {
             for (IgniteCacheProxy cache : ((IgniteKernal)first).caches()) {
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/MarshallerContextLockingSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/MarshallerContextLockingSelfTest.java
index 337a07200bea0..f160816432a51 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/MarshallerContextLockingSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/MarshallerContextLockingSelfTest.java
@@ -21,8 +21,6 @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicInteger;
 import org.apache.ignite.IgniteInterruptedException;
 import org.apache.ignite.IgniteLogger;
@@ -32,6 +30,7 @@
 import org.apache.ignite.internal.processors.marshaller.MarshallerMappingItem;
 import org.apache.ignite.internal.processors.marshaller.MarshallerMappingTransport;
 import org.apache.ignite.internal.processors.pool.PoolProcessor;
+import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.internal.util.lang.GridPlainRunnable;
 import org.apache.ignite.internal.util.typedef.internal.U;
 import org.apache.ignite.testframework.GridTestClassLoader;
@@ -41,6 +40,7 @@
 import org.junit.Test;
 
 import static org.apache.ignite.internal.MarshallerPlatformIds.JAVA_ID;
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newFixedThreadPool;
 
 /**
  * Test marshaller context.
@@ -69,9 +69,9 @@ public class MarshallerContextLockingSelfTest extends GridCommonAbstractTest {
         };
 
         ctx.add(new PoolProcessor(ctx) {
-            final ExecutorService sysExecSvc = Executors.newFixedThreadPool(THREADS);
+            final IgniteThreadPoolExecutor sysExecSvc = newFixedThreadPool("test-scope", "sys", THREADS);
 
-            @Override public ExecutorService getSystemExecutorService() {
+            @Override public IgniteThreadPoolExecutor getSystemExecutorService() {
                 return sysExecSvc;
             }
         });
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/managers/IgniteDiagnosticPartitionReleaseFutureLimitTest.java b/modules/core/src/test/java/org/apache/ignite/internal/managers/IgniteDiagnosticPartitionReleaseFutureLimitTest.java
index caa4db12ee341..c82e27c068b75 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/managers/IgniteDiagnosticPartitionReleaseFutureLimitTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/managers/IgniteDiagnosticPartitionReleaseFutureLimitTest.java
@@ -19,7 +19,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.atomic.AtomicBoolean;
 import org.apache.ignite.IgniteCache;
 import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
@@ -30,6 +29,7 @@
 import org.apache.ignite.internal.IgniteInternalFuture;
 import org.apache.ignite.internal.TestRecordingCommunicationSpi;
 import org.apache.ignite.internal.processors.cache.distributed.dht.atomic.GridDhtAtomicDeferredUpdateResponse;
+import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.internal.util.typedef.T4;
 import org.apache.ignite.internal.util.typedef.internal.U;
 import org.apache.ignite.testframework.GridTestUtils;
@@ -147,7 +147,7 @@ private IgniteInternalFuture<List<T4<Long, Integer, Integer, String>>> startTrac
         AtomicBoolean stop
     ) {
         IgniteInternalFuture<List<T4<Long, Integer, Integer, String>>> futExec = GridTestUtils.runAsync(() -> {
-            ThreadPoolExecutor exec = (ThreadPoolExecutor)node.context().pools().getSystemExecutorService();
+            IgniteThreadPoolExecutor exec = node.context().pools().getSystemExecutorService();
 
             List<T4<Long, Integer, Integer, String>> inf = new ArrayList<>();
 
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/snapshot/dump/AbstractCacheDumpTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/snapshot/dump/AbstractCacheDumpTest.java
index 571a1dc785d39..394f6f863617e 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/snapshot/dump/AbstractCacheDumpTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/snapshot/dump/AbstractCacheDumpTest.java
@@ -26,7 +26,6 @@
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ThreadPoolExecutor;
 import java.util.function.IntConsumer;
 import java.util.function.IntFunction;
 import java.util.stream.Collectors;
@@ -288,7 +287,7 @@ protected T2<CountDownLatch, IgniteInternalFuture<?>> runDumpAsyncAndStopBeforeS
                 if (ign.configuration().isClientMode() == Boolean.TRUE)
                     continue;
 
-                if (((ThreadPoolExecutor)((IgniteEx)ign).context().pools().getSnapshotExecutorService()).getTaskCount() <= 1)
+                if (((IgniteEx)ign).context().pools().getSnapshotExecutorService().getTaskCount() <= 1)
                     return false;
             }
 
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/transactions/TxRecoveryConcurrentTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/transactions/TxRecoveryConcurrentTest.java
index 970c56c43d29b..df487501152ac 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/transactions/TxRecoveryConcurrentTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/transactions/TxRecoveryConcurrentTest.java
@@ -21,7 +21,6 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ThreadPoolExecutor;
 import org.apache.ignite.Ignite;
 import org.apache.ignite.IgniteCache;
 import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
@@ -32,7 +31,6 @@
 import org.apache.ignite.internal.IgniteInterruptedCheckedException;
 import org.apache.ignite.internal.TestRecordingCommunicationSpi;
 import org.apache.ignite.internal.util.typedef.G;
-import org.apache.ignite.testframework.GridTestUtils;
 import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
 import org.apache.ignite.transactions.TransactionState;
 import org.junit.Test;
@@ -40,6 +38,7 @@
 import static org.apache.ignite.cache.CacheAtomicityMode.TRANSACTIONAL;
 import static org.apache.ignite.cache.CacheMode.PARTITIONED;
 import static org.apache.ignite.testframework.GridTestUtils.runAsync;
+import static org.apache.ignite.testframework.GridTestUtils.waitForCondition;
 
 /**
  * Tests concurrent execution of the tx recovery.
@@ -165,13 +164,11 @@ public void testRecoveryNotDeadLockOnNearAndPrimaryFail() throws Exception {
 
     /** */
     private void waitForTxRecoveryRequestEnqueuedOn(IgniteEx grid) throws IgniteInterruptedCheckedException {
-        assertTrue(GridTestUtils.waitForCondition(() ->
-            grid.context().pools().getStripedExecutorService().queueStripeSize(0) > 0, 5_000, 10));
+        assertTrue(waitForCondition(() -> grid.context().pools().getStripedExecutorService().queueStripeSize(0) > 0, 5_000, 10));
     }
 
     /** */
     private void waitForTxRecoveryTaskEnqueuedOn(IgniteEx grid) throws IgniteInterruptedCheckedException {
-        assertTrue(GridTestUtils.waitForCondition(() ->
-            !((ThreadPoolExecutor)grid.context().pools().getSystemExecutorService()).getQueue().isEmpty(), 5_000, 10));
+        assertTrue(waitForCondition(() -> !(grid.context().pools().getSystemExecutorService()).getQueue().isEmpty(), 5_000, 10));
     }
 }
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/thread/context/OperationContextAttributesTest.java b/modules/core/src/test/java/org/apache/ignite/internal/thread/context/OperationContextAttributesTest.java
index 788321c9efff0..c6d1a7376bd9b 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/thread/context/OperationContextAttributesTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/thread/context/OperationContextAttributesTest.java
@@ -26,9 +26,11 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingQueue;
 import org.apache.ignite.internal.managers.communication.GridIoPolicy;
-import org.apache.ignite.internal.thread.pool.OperationContextAwareStripedExecutor;
-import org.apache.ignite.internal.thread.pool.OperationContextAwareStripedThreadPoolExecutor;
-import org.apache.ignite.internal.thread.pool.OperationContextAwareThreadPoolExecutor;
+import org.apache.ignite.internal.thread.pool.IgniteForkJoinPool;
+import org.apache.ignite.internal.thread.pool.IgniteScheduledThreadPoolExecutor;
+import org.apache.ignite.internal.thread.pool.IgniteStripedExecutor;
+import org.apache.ignite.internal.thread.pool.IgniteStripedThreadPoolExecutor;
+import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
 import org.junit.Test;
 
@@ -457,7 +459,7 @@ public void testSnapshotScopeUnorderedClosing() {
     /** */
     @Test
     public void testContextAwareThreadPool() throws Exception {
-        OperationContextAwareThreadPoolExecutor pool = deferShutdown(new OperationContextAwareThreadPoolExecutor(
+        IgniteThreadPoolExecutor pool = deferShutdown(new IgniteThreadPoolExecutor(
             "test",
             null,
             1,
@@ -473,7 +475,7 @@ public void testContextAwareThreadPool() throws Exception {
     /** */
     @Test
     public void testContextAwareStripedThreadPoolExecutor() throws Exception {
-        OperationContextAwareStripedThreadPoolExecutor pool = deferShutdown(new OperationContextAwareStripedThreadPoolExecutor(
+        IgniteStripedThreadPoolExecutor pool = deferShutdown(new IgniteStripedThreadPoolExecutor(
             2,
             getTestIgniteInstanceName(0),
             "",
@@ -492,7 +494,7 @@ public void testContextAwareStripedThreadPoolExecutor() throws Exception {
     /** */
     @Test
     public void testContextAwareStripedExecutor() throws Exception {
-        OperationContextAwareStripedExecutor pool = deferShutdown(new OperationContextAwareStripedExecutor(
+        IgniteStripedExecutor pool = deferShutdown(new IgniteStripedExecutor(
             2,
             getTestIgniteInstanceName(0),
             "",
@@ -513,6 +515,41 @@ public void testContextAwareStripedExecutor() throws Exception {
         AttributeValueChecker.assertAllCreatedChecksPassed();
     }
 
+    /** */
+    @Test
+    public void testThreadContextAwareScheduledThreadPoolExecutor() throws Exception {
+        IgniteScheduledThreadPoolExecutor pool = deferShutdown(new IgniteScheduledThreadPoolExecutor("test", "test", 1));
+
+        doContextAwareExecutorServiceTest(pool);
+
+        CountDownLatch poolUnblockedLatch = blockPool(pool);
+
+        BiConsumerX<String, Integer> checks = (s, i) -> {
+            pool.schedule((Callable<Integer>)new AttributeValueChecker(s, i), 100, MILLISECONDS);
+            pool.schedule((Runnable)new AttributeValueChecker(s, i), 100, MILLISECONDS);
+            pool.scheduleAtFixedRate(new AttributeValueChecker(s, i), 100, 100, MILLISECONDS);
+            pool.scheduleWithFixedDelay(new AttributeValueChecker(s, i), 100, 100, MILLISECONDS);
+        };
+
+        createAttributeChecks(checks);
+
+        poolUnblockedLatch.countDown();
+
+        AttributeValueChecker.assertAllCreatedChecksPassed();
+    }
+
+    /** */
+    @Test
+    public void testThreadContextAwareForkJoinCommonPool() throws Exception {
+        doContextAwareExecutorServiceTest(IgniteForkJoinPool.commonPool());
+    }
+
+    /** */
+    @Test
+    public void testThreadContextAwareForkJoinPool() throws Exception {
+        doContextAwareExecutorServiceTest(deferShutdown(new IgniteForkJoinPool("test", "test", 2, null, false)));
+    }
+
     /** */
     private void doContextAwareExecutorServiceTest(ExecutorService pool) throws Exception {
         CountDownLatch poolUnblockedLatch = blockPool(pool);
@@ -568,8 +605,12 @@ private void createAttributeChecks(BiConsumerX<String, Integer> checkGenerator)
             checkGenerator.accept("test1", 1);
         }
 
-        try (Scope ignored = OperationContext.set(STR_ATTR, "test2", INT_ATTR, 2)) {
-            checkGenerator.accept("test2", 2);
+        try (Scope ignored = OperationContext.set(INT_ATTR, 2)) {
+            checkGenerator.accept(DFLT_STR_VAL, 2);
+        }
+
+        try (Scope ignored = OperationContext.set(STR_ATTR, "test2")) {
+            checkGenerator.accept("test2", DFLT_INT_VAL);
         }
 
         checkGenerator.accept(DFLT_STR_VAL, DFLT_INT_VAL);
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/util/future/GridFutureAdapterSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/util/future/GridFutureAdapterSelfTest.java
index b2eaaf07aeb58..612b82c3d8821 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/util/future/GridFutureAdapterSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/util/future/GridFutureAdapterSelfTest.java
@@ -33,6 +33,7 @@
 import org.apache.ignite.internal.processors.pool.PoolProcessor;
 import org.apache.ignite.internal.processors.security.NoOpIgniteSecurityProcessor;
 import org.apache.ignite.internal.thread.IgniteThreadFactory;
+import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.internal.util.typedef.CI1;
 import org.apache.ignite.internal.util.typedef.CX1;
 import org.apache.ignite.lang.IgniteClosure;
@@ -40,6 +41,7 @@
 import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
 import org.junit.Test;
 
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newSingleThreadExecutor;
 import static org.apache.ignite.testframework.GridTestUtils.assertThrows;
 
 /**
@@ -186,15 +188,15 @@ public void testListenNotify() throws Exception {
         ctx.add(new NoOpIgniteSecurityProcessor(ctx));
 
         ctx.add(new PoolProcessor(ctx) {
-            final ExecutorService execSvc = Executors.newSingleThreadExecutor(new IgniteThreadFactory("testscope", "exec-svc"));
+            final IgniteThreadPoolExecutor execSvc = newSingleThreadExecutor("testscope", "exec-svc");
 
-            final ExecutorService sysExecSvc = Executors.newSingleThreadExecutor(new IgniteThreadFactory("testscope", "system-exec"));
+            final IgniteThreadPoolExecutor sysExecSvc = newSingleThreadExecutor("testscope", "system-exec");
 
-            @Override public ExecutorService getSystemExecutorService() {
+            @Override public IgniteThreadPoolExecutor getSystemExecutorService() {
                 return sysExecSvc;
             }
 
-            @Override public ExecutorService getExecutorService() {
+            @Override public IgniteThreadPoolExecutor getExecutorService() {
                 return execSvc;
             }
         });
diff --git a/modules/core/src/test/java/org/apache/ignite/marshaller/MarshallerContextSelfTest.java b/modules/core/src/test/java/org/apache/ignite/marshaller/MarshallerContextSelfTest.java
index 5e445271aec12..f140e37efc80c 100644
--- a/modules/core/src/test/java/org/apache/ignite/marshaller/MarshallerContextSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/marshaller/MarshallerContextSelfTest.java
@@ -23,8 +23,6 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import org.apache.ignite.Ignite;
 import org.apache.ignite.IgniteCheckedException;
@@ -35,6 +33,7 @@
 import org.apache.ignite.internal.processors.marshaller.MappedName;
 import org.apache.ignite.internal.processors.marshaller.MarshallerMappingItem;
 import org.apache.ignite.internal.processors.pool.PoolProcessor;
+import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.internal.util.typedef.internal.U;
 import org.apache.ignite.testframework.junits.GridTestKernalContext;
 import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
@@ -43,6 +42,7 @@
 
 import static java.nio.file.Files.readAllBytes;
 import static org.apache.ignite.internal.MarshallerPlatformIds.JAVA_ID;
+import static org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor.newSingleThreadExecutor;
 
 /**
  * Test marshaller context.
@@ -52,15 +52,15 @@ public class MarshallerContextSelfTest extends GridCommonAbstractTest {
     private GridTestKernalContext ctx;
 
     /** */
-    private ExecutorService execSvc;
+    private IgniteThreadPoolExecutor execSvc;
 
     /** {@inheritDoc} */
     @Override protected void beforeTest() throws Exception {
         ctx = newContext();
-        execSvc = Executors.newSingleThreadExecutor();
+        execSvc = newSingleThreadExecutor("test-scope", "sys");
 
         ctx.add(new PoolProcessor(ctx) {
-            @Override public ExecutorService getSystemExecutorService() {
+            @Override public IgniteThreadPoolExecutor getSystemExecutorService() {
                 return execSvc;
             }
         });
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/IgniteTestResources.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/IgniteTestResources.java
index 98a52fe67ebab..a51e7b5339c73 100644
--- a/modules/core/src/test/java/org/apache/ignite/testframework/junits/IgniteTestResources.java
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/IgniteTestResources.java
@@ -22,7 +22,6 @@
 import java.util.UUID;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
 import javax.management.MBeanServer;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.IgniteLogger;
@@ -62,7 +61,7 @@ public class IgniteTestResources {
     private final String home = U.getIgniteHome();
 
     /** */
-    private ThreadPoolExecutor execSvc;
+    private IgniteThreadPoolExecutor execSvc;
 
     /** */
     private IgniteConfiguration cfg;
@@ -160,8 +159,13 @@ public GridResourceProcessor resources() {
      * @param prestart Prestart flag.
      */
     public void startThreads(boolean prestart) {
-        execSvc = new IgniteThreadPoolExecutor(nodeId.toString(), null, 40, 40, Long.MAX_VALUE,
-                new LinkedBlockingQueue<>());
+        execSvc = new IgniteThreadPoolExecutor(
+            nodeId.toString(),
+            null,
+            40,
+            40,
+            Long.MAX_VALUE,
+            new LinkedBlockingQueue<>());
 
         // Improve concurrency for testing.
         if (prestart)
diff --git a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/KillQueryErrorOnCancelTest.java b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/KillQueryErrorOnCancelTest.java
index b655bd5cca6e6..9072d8c476a31 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/KillQueryErrorOnCancelTest.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/KillQueryErrorOnCancelTest.java
@@ -21,7 +21,6 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.UUID;
-import java.util.concurrent.ThreadPoolExecutor;
 import org.apache.ignite.IgniteException;
 import org.apache.ignite.cache.query.FieldsQueryCursor;
 import org.apache.ignite.cache.query.SqlFieldsQuery;
@@ -33,6 +32,7 @@
 import org.apache.ignite.internal.managers.communication.GridIoPolicy;
 import org.apache.ignite.internal.processors.query.h2.twostep.messages.GridQueryCancelRequest;
 import org.apache.ignite.internal.processors.query.running.GridRunningQueryInfo;
+import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.lang.IgniteInClosure;
 import org.apache.ignite.plugin.extensions.communication.Message;
 import org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi;
@@ -158,7 +158,7 @@ private void ensureMapQueriesHasFinished(IgniteEx node) throws Exception {
      * no queries are executed at the moment; {@code false} otherwise.
      */
     private boolean queryPoolIsEmpty(IgniteEx node) {
-        ThreadPoolExecutor qryPool = (ThreadPoolExecutor)node.context().pools().getQueryExecutorService();
+        IgniteThreadPoolExecutor qryPool = node.context().pools().getQueryExecutorService();
 
         return qryPool.getQueue().isEmpty() && qryPool.getActiveCount() == 0;
     }
diff --git a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/KillQueryTest.java b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/KillQueryTest.java
index 974326c729b48..cab13cda4d343 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/KillQueryTest.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/KillQueryTest.java
@@ -34,7 +34,6 @@
 import java.util.concurrent.BrokenBarrierException;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.CyclicBarrier;
-import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -78,6 +77,7 @@
 import org.apache.ignite.internal.processors.query.h2.twostep.msg.GridH2QueryRequest;
 import org.apache.ignite.internal.processors.query.running.GridRunningQueryInfo;
 import org.apache.ignite.internal.processors.query.schema.message.SchemaProposeDiscoveryMessage;
+import org.apache.ignite.internal.thread.pool.IgniteThreadPoolExecutor;
 import org.apache.ignite.internal.util.GridSpinBusyLock;
 import org.apache.ignite.internal.util.typedef.F;
 import org.apache.ignite.internal.util.typedef.internal.U;
@@ -981,7 +981,7 @@ private void ensureMapQueriesHasFinished(IgniteEx node) throws Exception {
      * no queries are executed at the moment; {@code false} otherwise.
      */
     private boolean queryPoolIsEmpty(IgniteEx node) {
-        ThreadPoolExecutor qryPool = (ThreadPoolExecutor)node.context().pools().getQueryExecutorService();
+        IgniteThreadPoolExecutor qryPool = node.context().pools().getQueryExecutorService();
 
         return qryPool.getQueue().isEmpty() && qryPool.getActiveCount() == 0;
     }
diff --git a/parent/pom.xml b/parent/pom.xml
index 13423a9cde2c4..b6d05a3d1eb33 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -240,7 +240,6 @@
                         <outputFile>${project.build.directory}/checkstyle-result.xml</outputFile>
                         <!-- This configuration checkstyle files will be obtained from the 'ignite-checkstyle' resources. -->
                         <configLocation>checkstyle/checkstyle.xml</configLocation>
-                        <suppressionsLocation>checkstyle/checkstyle-suppressions.xml</suppressionsLocation>
                         <includeTestSourceDirectory>true</includeTestSourceDirectory>
                         <excludes>**/generated/**/*</excludes>
                     </configuration>