最新消息:发现真没时间折腾VPS,最近又换了个空间。呵呵

Java线程池的使用

关于为什么要使用线程池,网上的介绍有很多,简单地说,就是对于非即时性程序来说,使用池程池可以大量节约系统资源。一般来说,Java线程也是有限制的,网上说好像是3万左右。如果不使用线程池的话,对于短时间大量访问的操作来说,系统很可能会崩溃。使用线程池的话,可以自己控制线程数,控制系统开销。

Java通用java.util.concurrent.Executors类提供了一个简单的线程池,基本上能满足大多数功能了。Executors提供了四个方法,分别是:线程数固定线程池 newFixedThreadPool;单线程线程池 newSingleThreadExecutor;任务等量线程池 newCachedThreadPool;单线程循环执行线程池 newSingleThreadScheduledExecutor。

这四个方法的简单使用代码如下:

Java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestRun {
    public static int TASK_COUNT = 30;

    public static void main(String[] args) {
        testFixed();
        testSingle();
        testCached();
        testSchedule();
    }
    /**
     * 固定线程数
     */
    private static void testFixed() {
        ExecutorService sevice = Executors.newFixedThreadPool(5);
        for (int i = 1; i <= TASK_COUNT; i++) {
            sevice.submit(new Task("Fixed-" + i));
        }
        sevice.shutdown();
    }
    /**
     * 单线程
     */
    private static void testSingle() {
        ExecutorService sevice = Executors.newSingleThreadExecutor();
        for (int i = 1; i <= TASK_COUNT; i++) {
            sevice.submit(new Task("Single-" + i));
        }
        sevice.shutdown();
    }
    /**
     * 一个任务一个线程
     */
    private static void testCached() {
        ExecutorService sevice = Executors.newCachedThreadPool();
        for (int i = 1; i <= TASK_COUNT; i++) {
            sevice.submit(new Task("Cached-" + i));
        }
        sevice.shutdown();
    }
    /**
     * 单线程循环执行
     */
    private static void testSchedule() {
        ScheduledExecutorService sevice = Executors.newSingleThreadScheduledExecutor();
        for (int i = 1; i <= TASK_COUNT; i++) {
            sevice.scheduleAtFixedRate(new Task("Schedule-" + i), 0, 1, TimeUnit.SECONDS);
        }
        try {
            Thread.sleep(50000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sevice.shutdown();
    }

    static class Task implements Runnable {
        private String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            String outString = String.format("Task: %s, Thread: %s", name,
                    Thread.currentThread().getName());
            System.out.println("Start->" + outString);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("End  ->" + outString);
        }
    }
}

转载请注明:宇托的狗窝 » Java线程池的使用

发表我的评论
取消评论

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址