Java program ape will be four thread pool

Preface for Java programs ape, the thread pool is a high-frequency interview questions, we must master a skill, give you on this article uses four main thread pool.

Introduction thread pool

Thread pool concept:

The thread pool is to first create some threads, their set is called a thread pool. Use the thread pool may well improve performance, the thread pool is to create a large number of idle threads at system startup, the program will pass a task thread pool, thread pool will start a thread to perform this task, after the end of execution, the thread and do not die, but returned again to the thread pool becomes idle, waiting for the next task.

Thread pool mechanism:

In programming mode thread pool, the task is to be submitted to the whole thread pool instead submitted directly to a thread, the thread pool task in getting it to find out whether there is an idle thread inside, if there are, then the task of the cross to an idle thread.

A thread can only perform one task at the same time, but you can submit multiple tasks at the same time to a thread pool.

Use the thread pool reasons:

Multi-threaded runtime, the system constantly new thread startup and shutdown, the cost is very high, the transition will consume system resources, and the risk of transition switching threads, which may lead to the collapse of system resources. In this case, the thread pool is the best choice.

Detailed four common thread pool

4.1 Executors.newCacheThreadPool()

Executors.newCacheThreadPool () : cacheable thread pool, the pool has no thread to see previously established, if there is, it is used directly. If not, build a new thread to join the pool, pond cache type commonly used to perform some of the tasks the lifetime of an asynchronous short

Code:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
// create a thread pool cacheable
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
try {
// sleep can clearly see the inside using a thread pool thread before, did not create a new thread
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace ();
}
cachedThreadPool.execute(new Runnable() {
public void run() {
// cache thread is executing Print
System.out.println (Thread.currentThread () getName () + ". Being executed " );
}
});
}
}
}

Thread pool is infinite, on a task has been completed when the execution of the current task will be a complex task on the thread execution, rather than each time a new thread

4.2 Executors.newFixedThreadPool(int n)

Executors.newFixedThreadPool (n-int) : creates a fixed number of reusable thread pool, shared unbounded queue threads to run.

Code:

package com.study.test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
// create a reusable fixed number of thread pool
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
fixedThreadPool.execute(new Runnable() {
public void run() {
try {
// cache thread is executing Print
System.out.println (Thread.currentThread () getName () + ". Being executed " );
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace ();
}
}
});
}
}
}
}

4.3 Executors.newScheduledThreadPool(int n)

Executors.newScheduledThreadPool (the n-int) : create a fixed-length thread pool to support regular and periodic task execution

Code:

package com.study.test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
// create a fixed-size thread pool to support regular and periodic task execution - delayed execution
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// delay of 1 Miao execution
scheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println ( " delay . 1 seconds executed " );
}
}, 1, TimeUnit.SECONDS);
}
}

Output Results: Delay . 1 seconds executed

Code 2 : Timing can be performed

package com.study.test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
// create a fixed-size thread pool to support regular and periodic task execution - regular basis
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// Delay 1 every second after 3 to perform a second
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
public void run() {
System.out.println ( " Delay 1 after every second . 3 seconds to perform a " );
}
}, 1, 3, TimeUnit.SECONDS);
}
}

4.4 Executors.newSingleThreadExecutor ()

Executors.newSingleThreadExecutor () : Creates a single-threaded thread pool, use it only to perform the task only worker threads to ensure that all tasks in a specified order (FIFO, LIFO, priorities ) execution.

package com.study.test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestThreadPoolExecutor {
public static void main(String[] args) {
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
try {
// result is sequentially output, equivalent to the implementation of each task order
System.out.println (Thread.currentThread () getName () + ". Is being executed , the value of the print is :" + index);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace ();
}
}
});
}
}
}