lconcise
lconcise

[深入学习]JAVA线程池[转载]

通过new Thread来创建一个线程，由于线程的创建和销毁都需要消耗一定的CPU资源，所以在高并发下这种创建线程的方式将严重影响代码执行效率。而线程池的作用就是让一个线程执行结束后不马上销毁，继续执行新的任务，这样就节省了不断创建线程和销毁线程的开销。

  1. ThreadPoolExecutor
  2. 关闭线程池
  3. 4种拒绝策略
    3.1 CallerRunsPolicy
    3.2 AbortPolicy
    3.3 DiscardOldestPolicy
    3.4 DiscardPolicy
  4. 线程池的工厂方法
    4.1 newFixedThreadPool
    4.2 newCachedThreadPool
    4.3 newSingleThreadPool
    4.4 newScheduleThreadPool
  5. ThreadPoolExecutor 一些API的用法

ThreadPoolExecutor

创建Java线程池最核心的类 ThreadPoolExecutor:


image.png

它提供了四种构造函数，最核心的构造函数如下：

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

这7个参数的含义如下：

    /**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:

     *         {@code corePoolSize < 0}

     *         {@code keepAliveTime < 0}

     *         {@code maximumPoolSize <= 0}

     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
  1. corePoolSize 线程池核心线程数。即线程池中保留的线程个数，即使这些线程是空闲的，也不会被销毁，除非通过ThreadPoolExecutor的allowCoreThreadTimeOut(true)方法开启了核心线程的超时策略；
  2. maximumPoolSize 线程池中允许的最大线程个数；
  3. keepAliveTime 用于设置那些超出核心线程数量的线程的最大等待时间，超过这个时间还没有新任务的话，超出的线程将被销毁；
  4. unit 超时时间单位；
  5. workQueue 线程队列。用于保存通过execute方法提交的，等待被执行的任务；
  6. threadFactory 线程创建工程，即指定怎样创建线程；
  7. handler 拒绝策略。即指定当线程提交的数量超出了maximumPoolSize后，该使用什么策略处理超出的线程。

下面看个例子，加入理解：

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                1, 2, 10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new,
                new ThreadPoolExecutor.AbortPolicy());
        System.out.println("===  线程池创建完毕");

        int activeCount = -1;
        int queueSize = -1;
        while (true) {
            if (activeCount != threadPoolExecutor.getActiveCount()
                    || queueSize != threadPoolExecutor.getQueue().size()) {
                System.out.println("===  活跃线程个数： " + threadPoolExecutor.getActiveCount());
                System.out.println("===  核心线程个数： " + threadPoolExecutor.getCorePoolSize());
                System.out.println("===  队列线程个数： " + threadPoolExecutor.getQueue().size());
                System.out.println("===  最大线程数  ： " + threadPoolExecutor.getMaximumPoolSize());
                System.out.println("-------------------------------------");
                activeCount = threadPoolExecutor.getActiveCount();
                queueSize = threadPoolExecutor.getQueue().size();
            }
        }
    }

上面的代码创建了一个核心线程数量为1，允许最大线程数量为2，最大活跃时间为10秒，线程队列长度为1的线程池。

我们通过execute方法向线程池提交一个任务。

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                1, 2, 10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new,
                new ThreadPoolExecutor.AbortPolicy());
        System.out.println("===  线程池创建完毕");

        threadPoolExecutor.execute(() -> sleep(10));

        int activeCount = -1;
        int queueSize = -1;
        while (true) {
            if (activeCount != threadPoolExecutor.getActiveCount()
                    || queueSize != threadPoolExecutor.getQueue().size()) {
                System.out.println("===  活跃线程个数： " + threadPoolExecutor.getActiveCount());
                System.out.println("===  核心线程个数： " + threadPoolExecutor.getCorePoolSize());
                System.out.println("===  队列线程个数： " + threadPoolExecutor.getQueue().size());
                System.out.println("===  最大线程数  ： " + threadPoolExecutor.getMaximumPoolSize());
                System.out.println("-------------------------------------");
                activeCount = threadPoolExecutor.getActiveCount();
                queueSize = threadPoolExecutor.getQueue().size();
            }
        }
    }

    private static void sleep(long value) {
        try {
            System.out.println("===  " + Thread.currentThread().getName() + "线程执行sleep方法");
            TimeUnit.SECONDS.sleep(value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

ThreadPoolExecutor的execute和submit方法都可以向线程池提交任务，区别是，submit方法能够返回执行结果，返回值类型为Future

启动线程，控制台如下输出：

===  线程池创建完毕
===  活跃线程个数： 1
===  Thread-0线程执行sleep方法
===  核心线程个数： 1
===  队列线程个数： 0
===  最大线程数  ： 2
-------------------------------------

10秒后，控制台如下输出：

===  线程池创建完毕
===  活跃线程个数： 1
===  Thread-0线程执行sleep方法
===  核心线程个数： 1
===  队列线程个数： 0
===  最大线程数  ： 2
-------------------------------------
===  活跃线程个数： 0
===  核心线程个数： 1
===  队列线程个数： 0
===  最大线程数  ： 2
-------------------------------------

线程核心线程数量为1，通过execute提交一个任务之后，由于核心线程是空的，所以任务被执行了，这个任务的逻辑是休眠10秒，所以这10秒内，线程池的活跃线程数量为1。此外，并没有线程需要放到线程队列里等待，线程队列长度为0，
10秒后任务执行完成，活跃线程个数变为0。

我们通过execute方法向线程池提交2个任务，看看结果如何：

        threadPoolExecutor.execute(() -> sleep(10));
        threadPoolExecutor.execute(() -> sleep(10));

启动线程，控制结果如下：

===  线程池创建完毕
===  Thread-0线程执行sleep方法
===  活跃线程个数： 1
===  核心线程个数： 1
===  队列线程个数： 1
===  最大线程数  ： 2
-------------------------------------
===  Thread-0线程执行sleep方法
===  活跃线程个数： 1
===  核心线程个数： 1
===  队列线程个数： 0
===  最大线程数  ： 2
-------------------------------------
===  活跃线程个数： 0
===  核心线程个数： 1
===  队列线程个数： 0
===  最大线程数  ： 2
-------------------------------------

活跃个数为1，队列线程数为1,
10秒后，
活跃个数为1，队列线程数为0，
10秒后，
活跃个数为0，队列线程数为0。

我们通过execute方法向线程池提交3个任务，结果：

        threadPoolExecutor.execute(() -> sleep(10));
        threadPoolExecutor.execute(() -> sleep(10));
        threadPoolExecutor.execute(() -> sleep(10));

启动线程，控制台结果如下：

===  线程池创建完毕
===  Thread-0线程执行sleep方法
===  Thread-1线程执行sleep方法
===  活跃线程个数： 2
===  核心线程个数： 1
===  队列线程个数： 1
===  最大线程数  ： 2
-------------------------------------
===  Thread-1线程执行sleep方法
===  活跃线程个数： 1
===  核心线程个数： 1
===  队列线程个数： 0
===  最大线程数  ： 2
-------------------------------------
===  活跃线程个数： 0
===  核心线程个数： 1
===  队列线程个数： 0
===  最大线程数  ： 2
-------------------------------------

最大线程数为2，提交了3个任务，队列中也有等待任务，所以看到
活跃线程个数2，
队列线程个数1，
10秒后，
活跃线程个数1，
队列线程个数0，
10秒后，
活跃线程个数0，
队列线程个数1。

我们通过execute方法向线程池提交4个任务：

        threadPoolExecutor.execute(() -> sleep(10));
        threadPoolExecutor.execute(() -> sleep(10));
        threadPoolExecutor.execute(() -> sleep(10));
        threadPoolExecutor.execute(() -> sleep(10));

启动线程，控制台结果如下：

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task cc.mrbird.demo.MainDemo$$Lambda$5/159413332@3d494fbf rejected from java.util.concurrent.ThreadPoolExecutor@1ddc4ec2[Running, pool size = 2, active threads = 2, queued tasks = 1, completed tasks = 0]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
    at cc.mrbird.demo.MainDemo.main(MainDemo.java:24)
===  线程池创建完毕
===  Thread-0线程执行sleep方法
===  Thread-1线程执行sleep方法
===  Thread-0线程执行sleep方法

因为我们设置的拒绝策略为AbortPolicy，所以最后提交的那个任务直接被拒绝了。更多拒绝策略下面会介绍到。

关闭线程池

当线程池中所有任务都处理完毕后，线程并不会自己关闭。我们可以通过调用shutdown和shutdownNow方法来关闭线程池。两者的区别在于：

shutdown： Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted. Invocation has no additional effect if already shut down.

启动有序关闭，在此过程中执行先前提交的任务，但不接受任何新任务。如果已经关闭，调用不会产生额外的效果。这种方便平滑的关闭线程池。

shutdownNow :Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution. These tasks are drained (removed) from the task queue upon return from this method.

尝试停止所有正在积极执行的任务，停止处理等待的任务，并返回等待执行的任务列表。从该方法返回时，将从任务队列中删除这些任务。这种方法比较暴力。

通过代码去实践下：

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,
                4,
                10, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(2),
                Thread::new,
                new ThreadPoolExecutor.AbortPolicy());

        threadPoolExecutor.execute(new ShortTask());
        threadPoolExecutor.execute(new LongTask());
        threadPoolExecutor.execute(new ShortTask());
        threadPoolExecutor.execute(new LongTask());

        threadPoolExecutor.shutdown();

        System.out.println("===  已经执行了线程的shutdown方法");
    }

    static class ShortTask implements Runnable {
        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println("===  " + Thread.currentThread().getName() + " 执行shortTask完毕");
            } catch (InterruptedException e) {
                System.out.println("===  shortTask执行过程中被打断" + e.getMessage());
            }
        }
    }

    static class LongTask implements Runnable {
        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(5);
                System.out.println("===  " + Thread.currentThread().getName() + " 执行longTask完毕");
            } catch (InterruptedException e) {
                System.out.println("===  longTask执行过程中被打断" + e.getMessage());
            }
        }
    }

执行结果：

===  已经执行了线程的shutdown方法
===  Thread-0 执行shortTask完毕
===  Thread-0 执行shortTask完毕
===  Thread-1 执行longTask完毕
===  Thread-0 执行longTask完毕

可以看到，已经执行了shutdown()方法，并不会立即关闭线程池，而是等待所有被提交的任务都执行完了才关闭。

shutdownNow()例子：

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,
                4,
                10, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(2),
                Thread::new,
                new ThreadPoolExecutor.AbortPolicy());

        threadPoolExecutor.execute(new ShortTask());
        threadPoolExecutor.execute(new LongTask());
        threadPoolExecutor.execute(new ShortTask());
        threadPoolExecutor.execute(new LongTask());

        List runnables = threadPoolExecutor.shutdownNow();
        System.out.println("** " + runnables);

        System.out.println("===  已经执行了线程的shutdown方法");
    }

    static class ShortTask implements Runnable {
        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println("===  " + Thread.currentThread().getName() + " 执行shortTask完毕");
            } catch (InterruptedException e) {
                System.out.println("===  shortTask执行过程中被打断" + e.getMessage());
            }
        }
    }

    static class LongTask implements Runnable {
        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(5);
                System.out.println("===  " + Thread.currentThread().getName() + " 执行longTask完毕");
            } catch (InterruptedException e) {
                System.out.println("===  longTask执行过程中被打断" + e.getMessage());
            }
        }
    }

执行结果：

===  longTask执行过程中被打断sleep interrupted
** [cc.mrbird.demo.MainDemo2$ShortTask@27bc2616, cc.mrbird.demo.MainDemo2$LongTask@3941a79c]
===  已经执行了线程的shutdown方法
===  shortTask执行过程中被打断sleep interrupted

可以看到，在执行shutdownNow方法后，线程池马上被关闭，正在被执行的两个任务被打断，并且返回了线程队列中等待被执行的两个任务。

4种拒绝策略

当线程池无法接收新的任务的时候，可采取如下策略：


image.png

AbortPolicy策略： 丢弃任务，并抛出异常

上面那个例子就是AbortPolicy拒绝策略。

CallerRunsPolicy策略： 由调用线程处理该任务

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                1, 2, 10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new,
                new ThreadPoolExecutor.CallerRunsPolicy());
        System.out.println("===  线程池创建完毕");

        threadPoolExecutor.execute(() -> sleep(5));
        threadPoolExecutor.execute(() -> sleep(5));
        threadPoolExecutor.execute(() -> sleep(5));
        threadPoolExecutor.execute(() -> sleep(5));

    }

    private static void sleep(long value) {
        try {
            System.out.println("===  " + Thread.currentThread().getName() + "线程执行sleep方法");
            TimeUnit.SECONDS.sleep(value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

执行结果：

===  线程池创建完毕
===  Thread-0线程执行sleep方法
===  main线程执行sleep方法
===  Thread-1线程执行sleep方法
===  Thread-1线程执行sleep方法

DiscardOldestPolicy策略：丢弃最早被放入到线程队列的任务，将新提交的任务放入到线程队列末端

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                1, 2, 10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new,
                new ThreadPoolExecutor.DiscardOldestPolicy());
        System.out.println("===  线程池创建完毕");

        threadPoolExecutor.execute(() -> sleep(5,"任务一"));
        threadPoolExecutor.execute(() -> sleep(5,"任务二"));
        threadPoolExecutor.execute(() -> sleep(5,"任务三"));
        threadPoolExecutor.execute(() -> sleep(5,"任务四"));
    }

    private static void sleep(long value,String name) {
        try {
            System.out.println("===  " + Thread.currentThread().getName() + "线程执行sleep方法 "+name);
            TimeUnit.SECONDS.sleep(value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

执行结果：

===  线程池创建完毕
===  Thread-0线程执行sleep方法 任务一
===  Thread-1线程执行sleep方法 任务三
===  Thread-0线程执行sleep方法 任务四

DiscardPolicy策略：直接丢弃新的任务，不抛异常

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                1, 2, 10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new,
                new ThreadPoolExecutor.DiscardPolicy());
        System.out.println("===  线程池创建完毕");

        threadPoolExecutor.execute(() -> sleep(5,"任务一"));
        threadPoolExecutor.execute(() -> sleep(5,"任务二"));
        threadPoolExecutor.execute(() -> sleep(5,"任务三"));
        threadPoolExecutor.execute(() -> sleep(5,"任务四"));
    }

    private static void sleep(long value,String name) {
        try {
            System.out.println("===  " + Thread.currentThread().getName() + "线程执行sleep方法 "+name);
            TimeUnit.SECONDS.sleep(value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

执行结果：

===  线程池创建完毕
===  Thread-0线程执行sleep方法 任务一
===  Thread-1线程执行sleep方法 任务三
===  Thread-0线程执行sleep方法 任务二

线程池的工厂方法

除了使用ThreadPoolExecutor的构造方法创建线程池外，我们也可以使用Executors提供的工厂方法来创建不同类型的线程池：

        ExecutorService executorService01 = Executors.newFixedThreadPool(5);
        ExecutorService executorService02 = Executors.newCachedThreadPool();
        ExecutorService executorService03 = Executors.newSingleThreadExecutor();
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

newFixedThreadPool
查看newFixedThreadPool方法源码：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue());
}

可以看到，通过newFixedThreadPool创建的是一个固定大小的线程池，大小由nThreads参数指定，它具有如下几个特点:

  1. 因为corePoolSize和maximumPoolSize的值都为nThreads，所以线程池中线程数量永远等于nThreads，不可能新建除了核心线程数的线程来处理任务，即keepAliveTime实际上在这里是无效的。

  2. LinkedBlockingQueue是一个无界队列（最大长度为Integer.MAX_VALUE），所以这个线程池理论是可以无限的接收新的任务，这就是为什么上面没有指定拒绝策略的原因。

newCachedThreadPool
查看newCachedThreadPool方法源码：

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue());
}

这是一个理论上无限大小的线程池：

  1. 核心线程数为0，SynchronousQueue队列是没有长度的队列，所以当有新的任务提交，如果有空闲的还未超时的（最大空闲时间60秒）线程则执行该任务，否则新增一个线程来处理该任务。

  2. 因为线程数量没有限制，理论上可以接收无限个新任务，所以这里也没有指定拒绝策略。

newSingleThreadExecutor
查看newSingleThreadExecutor源码：

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue()));
}
  1. 核心线程数和最大线程数都为1，每次只能有一个线程处理任务。
  2. LinkedBlockingQueue队列可以接收无限个新任务。
    newScheduledThreadPool
    查看newScheduledThreadPool源码：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
......

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

所以newScheduledThreadPool理论是也是可以接收无限个任务，DelayedWorkQueue也是一个无界队列。

使用newScheduledThreadPool创建的线程池除了可以处理普通的Runnable任务外，它还具有调度的功能：

  1. 延时指定时间后执行：
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
        // 延时5秒执行
        executorService.schedule(() -> System.out.println("==  Hello"), 5, TimeUnit.SECONDS);

2.按指定速率执行：

        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
        // 按指定速率执行
        executorService.scheduleAtFixedRate(()->System.out.println(LocalDateTime.now()),3,5,TimeUnit.SECONDS);

执行结果：

2019-07-08T11:38:20.792
2019-07-08T11:38:25.776
2019-07-08T11:38:30.775
2019-07-08T11:38:35.773
2019-07-08T11:38:40.773
2019-07-08T11:38:45.774
  1. 按指定时延执行
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
        // 按指定时延执行
        executorService.scheduleWithFixedDelay(()->System.out.println(LocalDateTime.now()),3,5,TimeUnit.SECONDS);

执行结果：

2019-07-08T11:41:35.225
2019-07-08T11:41:40.228
2019-07-08T11:41:45.228
2019-07-08T11:41:50.230
2019-07-08T11:41:55.231
2019-07-08T11:42:00.232

乍一看，scheduleAtFixedRate和scheduleWithFixedDelay没啥区别，实际它们还是有区别的：

  1. scheduleAtFixedRate按照固定速率执行任务，比如每5秒执行一个任务，即使上一个任务没有结束，5秒后也会开始处理新的任务；
  2. scheduleWithFixedDelay按照固定的时延处理任务，比如每延迟5秒执行一个任务，无论上一个任务处理了1秒，1分钟还是1小时，下一个任务总是在上一个任务执行完毕后5秒钟后开始执行。

对于这些线程池工厂方法的使用，阿里巴巴编程规程指出：


image.png

因为这几个线程池理论是都可以接收无限个任务，所以这就有内存溢出的风险。实际上只要我们掌握了ThreadPoolExecutor构造函数7个参数的含义，我们就可以根据不同的业务来创建出符合需求的线程池。一般线程池的创建可以参考如下规则：

  1. IO密集型任务，线程池线程数量可以设置为2 X CPU核心数；
  2. 计算密集型任务，线程池线程数量可以设置为CPU核心数 + 1。

一些API的用法

ThreadPoolExecutor提供了几个判断线程池状态的方法：

    public static void main(String[] args) throws InterruptedException{
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 3,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new, new ThreadPoolExecutor.AbortPolicy());

        threadPoolExecutor.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        threadPoolExecutor.shutdown();
        System.out.println("===  线程为shutdown状态： " + threadPoolExecutor.isShutdown());
        System.out.println("===  线程池正在关闭： " + threadPoolExecutor.isTerminating());
        System.out.println("===  线程池已经关闭： " + threadPoolExecutor.isTerminated());
        // 阻塞当前线程，等待线程池关闭，timeout用于指定等待时间。
        threadPoolExecutor.awaitTermination(56,TimeUnit.SECONDS);
        System.out.println("===  线程池已经关闭： " + threadPoolExecutor.isTerminated());
    }

程序输出如下：

===  线程为shutdown状态： true
===  线程池正在关闭： true
===  线程池已经关闭： false
===  线程池已经关闭： true

前面我们提到，线程池核心线程即使是空闲状态也不会被销毁，除非使用allowCoreThreadTimeOut设置了允许核心线程超时：

    public static void main(String[] args) throws InterruptedException{
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                1, 2, 3,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new, new ThreadPoolExecutor.AbortPolicy());

        threadPoolExecutor.allowCoreThreadTimeOut(true);

        threadPoolExecutor.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
                System.out.println("===  任务执行完成");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }

5秒后任务执行完毕，核心线程处于空闲的状态。因为通过allowCoreThreadTimeOut方法设置了允许核心线程超时，所以3秒后（keepAliveTime设置为3秒），核心线程被销毁。核心线程被销毁后，线程池也就没有作用了，于是就自动关闭了。

值得注意的是，如果一个线程池调用了allowCoreThreadTimeOut(true)方法，那么它的keepAliveTime不能为0。

ThreadPoolExecutor提供了一remove方法，查看其源码：

    public boolean remove(Runnable task) {
        boolean removed = workQueue.remove(task);
        tryTerminate(); // In case SHUTDOWN and now empty
        return removed;
    }

可看到，它删除的是线程队列中的任务，而非正在被执行的任务。举个例子：

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                1, 2, 3,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new, new ThreadPoolExecutor.AbortPolicy());

        threadPoolExecutor.allowCoreThreadTimeOut(true);

        threadPoolExecutor.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
                System.out.println("===  任务执行完成");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Runnable runnable = () -> System.out.println("=== 看看我是否被删除");
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.remove(runnable);

        threadPoolExecutor.shutdown();
    }

程序输出：


image.png

可看到任务并没有被执行，已经被删除，因为唯一一个核心线程已经在执行任务了，所以后提交的这个任务被放到了线程队列里，然后通过remove方法删除。

默认情况下，只有当往线程池里提交了任务后，线程池才会启动核心线程处理任务。我们可以通过调用prestartCoreThread方法，让核心线程即使没有任务提交，也处于等待执行任务的活跃状态：

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2, 2, 3,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new, new ThreadPoolExecutor.AbortPolicy());

        System.out.println("=== 活跃线程个数： " + threadPoolExecutor.getActiveCount());
        threadPoolExecutor.prestartCoreThread();
        System.out.println("=== 活跃线程个数： " + threadPoolExecutor.getActiveCount());
        threadPoolExecutor.prestartCoreThread();
        System.out.println("=== 活跃线程个数： " + threadPoolExecutor.getActiveCount());
        threadPoolExecutor.prestartCoreThread();
        System.out.println("=== 活跃线程个数： " + threadPoolExecutor.getActiveCount());
    }

程序输出：
···
=== 活跃线程个数： 0
=== 活跃线程个数： 1
=== 活跃线程个数： 2
=== 活跃线程个数： 2
···
该方法返回boolean类型值，如果所以核心线程都启动了，返回false，反之返回true。

还有一个和它类似的prestartAllCoreThreads方法，它的作用是一次性启动所有核心线程，让其处于活跃地等待执行任务的状态。

ThreadPoolExecutor的invokeAny方法用于随机执行任务集合中的某个任务，并返回执行结果，该方法是同步方法：

    public static void main(String[] args) throws Exception{
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2, 5, 3,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new, new ThreadPoolExecutor.AbortPolicy());

        // 任务集合
        List> tasks = IntStream.range(0, 4).boxed().map(i -> (Callable) () -> {
            TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(5));
            return i;
        }).collect(Collectors.toList());
        // 随机执行结果
        Integer result = threadPoolExecutor.invokeAny(tasks);
        System.out.println("------------------");
        System.out.println(result);
        threadPoolExecutor.shutdown();
    }

程序输出：

------------------
0

ThreadPoolExecutor的invokeAll则是执行任务集合中的所有任务，返回Future集合：

    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2, 5, 3,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new, new ThreadPoolExecutor.AbortPolicy());

        // 任务集合
        List> tasks = IntStream.range(0, 4).boxed().map(i -> (Callable) () -> {
            TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(5));
            return i;
        }).collect(Collectors.toList());

        List> futures = threadPoolExecutor.invokeAll(tasks);
        futures.stream().map(f -> {
            try {
                return f.get();
            } catch (InterruptedException | ExecutionException e) {
                return null;
            }
        }).forEach(System.out::println);

        threadPoolExecutor.shutdownNow();
    }

程序输出如下：

0
1
2
3

总结如下方法：

方法 描述
allowCoreThreadTimeOut(boolean value) 是否允许核心线程空闲后超时，是的话超时后核心线程将销毁，线程池自动关闭
awaitTermination(long timeout, TimeUnit unit) 阻塞当前线程，等待线程池关闭，timeout用于指定等待时间。
execute(Runnable command) 向线程池提交任务，没有返回值
submit(Runnable task) 向线程池提交任务，返回Future
isShutdown() 判断线程池是否为shutdown状态
isTerminating() 判断线程池是否正在关闭
isTerminated() 判断线程池是否已经关闭
remove(Runnable task) 移除线程队列中的指定任务
prestartCoreThread() 提前让一个核心线程处于活跃状态，等待执行任务
prestartAllCoreThreads() 提前让所有核心线程处于活跃状态，等待执行任务
getActiveCount() 获取线程池活跃线程数
getCorePoolSize() 获取线程池核心线程数
threadPoolExecutor.getQueue() 获取线程池线程队列
getMaximumPoolSize() 获取线程池最大线程数
shutdown() 让线程池处于shutdown状态，不再接收任务，等待所有正在运行中的任务结束后，关闭线程池。
shutdownNow() 让线程池处于stop状态，不再接受任务，尝试打断正在运行中的任务，并关闭线程池，返回线程队列中的任务。

参考文章：
https://mrbird.cc/Java-Thread-Pool.html

你可能感兴趣的:([深入学习]JAVA线程池[转载])

  • 《如不承诺天长地久，怎会相遇细水长流》文/苏暖人 北京大数据苏焕之
    《如不承诺天长地久，怎会相遇细水长流》文/苏暖人原创——莫转载粘贴有人选择昙花一现，如大理的花海，有人选择细水长流，如雨夜的浪漫。都说，五分喜欢的人恨不得将他挂在嘴边，十分喜欢的人却只舍得放在心里边了，在爱情眼里，对方说的每一句话都在乎你的感受，TA的眼里也只有你，我想也是这样！说起我的爱情，我也喜欢过一个忧郁的女孩，她喜欢的男孩不喜欢她，于是我成了她倾诉的朋友＋备胎，一年来我们互相推荐伤感的歌曲
  • Python入门之Lesson2:Python基础语法 小熊同学哦 Python入门课程python开发语言算法数据结构青少年编程
    目录前言一.介绍1.变量和数据类型2.常见运算符3.输入输出4.条件语句5.循环结构二.练习三.总结前言欢迎来到《Python入门》系列博客的第二课。在上一课中，我们了解了Python的安装及运行环境的配置。在这一课中，我们将深入学习Python的基础语法，这是编写Python代码的根基。通过本节内容的学习，你将掌握变量、数据类型、运算符、输入输出、条件语句等Python编程的基础知识。一.介绍1
  • tiff批量转png 诺有缸的高飞鸟 opencv图像处理pythonopencv图像处理
    目录写在前面代码完写在前面1、本文内容tiff批量转png2、平台/环境opencv,python3、转载请注明出处：https://blog.csdn.net/qq_41102371/article/details/132975023代码importnumpyasnpimportcv2importosdeffindAllFile(base):file_list=[]forroot,ds,fsin
  • 使用由 Python 编写的 lxml 实现高性能 XML 解析 hunyxv python笔记pythonxml
    转载自：文章lxml简介Python从来不出现XML库短缺的情况。从2.0版本开始，它就附带了xml.dom.minidom和相关的pulldom以及SimpleAPIforXML(SAX)模块。从2.4开始，它附带了流行的ElementTreeAPI。此外，很多第三方库可以提供更高级别的或更具有python风格的接口。尽管任何XML库都足够处理简单的DocumentObjectModel(DOM
  • 讲担当促作为抓落实，持之以恒纠“四风”树新风 asdfdy
    讲担当促作为抓落实，持之以恒纠“四风”树新风习近平总书记在十九届中央纪委五次全会上发表重要讲话时强调，要毫不松懈纠治“四风”，坚决防止形式主义、官僚主义滋生蔓延。结合深入治理形式主义官僚主义不担当不作为问题专项行动和党史学习教育，纪检监察干部要把纠“四风”和树新风紧密结合起来，既坚决纠治“四风”顽疾，又大力发扬对党忠诚、实事求是、艰苦奋斗、清正廉洁等党的光荣传统和优良作风。一是要深入学习贯彻习近平
  • [转载] NoSQL简介 weixin_30325793 大数据数据库运维
    摘自“百度百科”。NoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。虽然NoSQL流行语
  • STM32的寄存器深度解析 千千道 STM32stm32单片机物联网
    目录一、STM32寄存器概述二、寄存器的定义与作用三、寄存器分类1.内核寄存器2.外设寄存器四、重要寄存器详解1.GPIO相关寄存器2.定时器相关寄存器3.中断相关寄存器4.RCC相关寄存器五、寄存器操作方法1.直接操作寄存器2.使用库函数操作寄存器六、总结在嵌入式系统开发中，STM32微控制器以其强大的性能和丰富的功能而备受青睐。而理解和掌握STM32的寄存器是深入学习和开发STM32的关键。本
  • 玄幻小说 《圣爱》第二十九章 梦中有梦（上） 碧海潮生2019
    作者：极天圣洺欢迎转载！转载注明“作者：极天圣洺”即可。图片发自App圣爱第一部跨世之恋第二十九章梦中有梦（上）有诗为证：“愿得一人心，白首不相离！卿卿月明日，嫦娥低语声！”正文月公主满脸的迟疑之色，双手扶起两人，“你们都是法力通天之人，而我也只是一个籍籍无名之凡人而已，两位前辈，快快请起！”“还是不要叫我月圣了，如果可以，称呼我一声，月公主，即可了！”月公主，满脸款款之笑，让这片黑夜中的虚空，在
  • 面试题24. 反转链表 阿星啊阿星
    反转链表题目描述定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点示例：输入:1->2->3->4->5->NULL输出:5->4->3->2->1->NULL提示：0<=节点个数<=5000转载来源：力扣（LeetCode）题目分析1→2→3→null初始化时h为1，now为2，h的next设置成null，有：null←1（h） 2（now）→3现在将保存一下now的next
  • Cisco SD-WAN (Viptela) 20.15.1 发布，新增功能概览 sysin.org CiSCOCiscoSD-WANViptela思科SDN软件定义广域网
    CiscoSD-WAN(Viptela)version20.15.1ED-软件定义广域网CiscoSD-WANpoweredbyViptela请访问原文链接：https://sysin.org/blog/cisco-sd-wan-20/，查看最新版。原创作品，转载请保留出处。作者主页：sysin.org支持SASE的架构，其集成了面向多云、安全、统一通信和应用优化的各种功能，可用于轻松安全地将任何
  • 史上最全的maven的pom.xml文件详解 Meta999 Maven
    注：详解文件中，用红色进行标注的是平常项目中常用的配置节点。要详细学习！转载的，太经典了、、、、欢迎收藏xxxxxxxxxxxx4.0.0xxxxxxjar1.0-SNAPSHOTxxx-mavenhttp://maven.apache.orgAmavenprojecttostudymaven.jirahttp://jira.baidu.com/[email protected]
  • 【网络安全】漏洞挖掘：php代码审计 秋说 网络安全phpweb安全漏洞挖掘
    未经许可，不得转载。文章目录正文正文在应用程序中，通过一个JavaScript注释发现了一个备份ZIP文件。解压后，获取了应用程序的代码，其中包含如下代码片段：代码首先检查变量$action是否等于'convert'，如果是，则继续执行。随后对传入的变量$data使用trim()函数去除两端空白字符，并使用eval()函数执行$data的内容。显然，代码对$data没有进行任何过滤或验证，因此可以
  • 【网络安全 | 代码审计】JFinal之DenyAccessJsp绕过 秋说 网络安全web安全java代码审计漏洞挖掘
    未经许可，不得转载。文章目录前言代码审计推理绕过Tomcat解析JSP总结概念验证阐发前言JFinal是一个基于Java的轻量级MVC框架，用于快速构建Web应用程序。它的设计理念是追求极简、灵活、高效，旨在提高开发效率，减少冗余代码的编写，适合中小型项目以及对性能有较高要求的项目。在较新的JFinal版本中，默认情况下无法直接通过浏览器地址栏输入.jsp文件名来访问对应的JSP文件。也就是说，主
  • “深圳红树林外国语小学”教育戏剧的师资培训 我爱教育戏剧
    2020年8月17日-18日，骑士教育戏剧为红树林外国语小学的老师们进行了一场师训，这篇文章由红树林外国语小学官方微信公众号撰写，骑士转载，以期更多学校了解教育戏剧走进校园的情况。暑假研修教育戏剧专场2020年8月16日-21日，红树林举行了为期六天的入职研修培训各位教育大咖空降来袭，带来了满满的干货讲座你以为红树林的培训只是听讲座吗？NO！NO！NO！在这里，红树林的培训还是这样的：还有这样的！
  • 在你身边 最后的夏（转载） Bojack没有jack
    滚烫的晴空万里，蓝天漂浮在温热的河水里，眩惑出如玉的水波，缠绵着水草轻柔荡漾，惊白色的水鸟掠起。酷暑消退在最纯净的午夜，寂静中万物屏息，澄澈的月光涤荡天地，唤起透明的星辰散落这里。夏天到来，令我回忆。清晨的光线竟略带寒意，漫天而过透明的露珠映着天地，絮状的梦如同回到冬季，美的就像，就像记忆。坐在教室里打哈欠的早读，捂着耳朵大声的背书，转转头，悄悄的注视你，静静的睡着。光线正好打在你脸上，柔和的像幼
  • D83转载转载转载！ 雨墨2021
    点鼻子请帮手晃动手指，然后用自己的食指点对方的手指。再来回点自己的鼻子，只要都能顺利点到对方的手指，就表示没有问题！如果来回几次都点空，甚至当手指停下不动的时候都无法点中，就一定要去医院检查了！当然这个只是我们自己检测的一个手段，因为有的时候脑梗出现的位置不同，导致的症状也不同，从而自测只能作为参考，如果有很明显的身体症状，可以迅速的去医院，做相关的检查。疾病的预防永远大于治疗，如果你不想脑梗到来
  • java 线程池 队列封装_java线程池（线程池组---分离任务队列和线程池） 爱打怪的小魔女 java线程池队列封装
    线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
  • 朱松纯委员：科研条件越来越好，为何颠覆性科学发现却越来越少？ 晨起动铮铎
    原文链接：https://mp.weixin.qq.com/s/2hzjWGcqjzhV0Yob7RmCsg原文转载自科学网文｜《中国科学报》记者赵广立“为什么近年来世界各国科研人员成倍增长、经费越来越多、科研条件越来越好，却产生不了根本性的科学发现？”近日，全国政协委员，北京通用人工智能研究院院长，北京大学、清华大学讲席教授朱松纯在一次发言中发出上述疑问。在他看来，重大基础性原创性科学成果“难产
  • 2024年最新Python面试简历模板，Python下载中国数据库大会（DTCC2024）PPT全集(3)，字节跳动面试难吗 2401_84123188 2024年程序员学习python面试数据库
    收集整理了一份《2024年最新Python全套学习资料》免费送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Python知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来如果你需要这些资料，可以添加V无偿获取：hxbc188（备注666）正文frombs4im
  • Oozie Bundle 规范 weixin_34075268
    为什么80%的码农都做不了架构师？>>>文档地址转载于:https://my.oschina.net/sskxyz/blog/756359
  • 1.25-1.26 Coordinator数据集和oozie bundle weixin_30851867
    一、Coordinator数据集二、ooziebundle转载于:https://www.cnblogs.com/weiyiming007/p/10881260.html
  • 深入学习-Gradle-自动化构建技术（五）Gradle-插件架构实现原理剖析- 2401_84002294 2024年程序员学习学习自动化架构
    6、AndroidGradlePluginV3.0.0（2017年10月）7、AndroidGradlePluginV2.3.0（2017年2月）三、Gradle构建核心流程解析1、LoadSettings2、Configure3、TaskGraph4、RunTasks5、Finished四、关于Gradle中依赖实现的原理1、通过MethodMissing机制，间接地调用DefaultDepen
  • 当大官的大表哥 春暖花开cws
    所有作品，本人原创，未经允许，不得转载或抄袭，违者必究！图片发自App我有一位大表哥，在上海做大官。这个大表哥，是大舅父的长子。上世纪七十年代，大表哥参了军，在信阳某部队。在自卫反击战中，大表哥参加侦察兵，插入到越军的腹地。有一次，一颗子弹从他的耳边呼啸而过，险而又险。大表哥立了功，加上他人也聪明，所以升职很快。从士兵做起到连级，从连级到营级，从营级到团级，从团级到师级，每一步都稳扎稳打，升职很快
  • Ubuntu搭建简易Postfix邮箱服务器 嫩草终结者 邮箱服务
    本文转载自https://www.linuxdashen.com/ubuntu%E6%90%AD%E5%BB%BA%E7%AE%80%E6%98%93postfix%E9%82%AE%E7%AE%B1%E6%9C%8D%E5%8A%A1%E5%99%A8Ubuntu搭建简易Postfix邮箱服务器最后更新2016年4月20日分类Ubuntu服务器最新文章邮件服务器标签550mailcontentd
  • Gerrit审核服务器搭建简易教程(Ubuntu 12.10) LKV_刘言
    //**********************************************欢迎转载，转载请注明出处，请尊重作者！http://blog.csdn.net/airk000Email:[email protected]//**********************************************本文将详细记录如何在一个全新的Ubuntu系统中安装及配置Gerri
  • 如何一步步解决 DP 问题 顽强的猫尾草
    转载自：https://leetcode.com/problems/house-robber/discuss/156523/From-good-to-great.-How-to-approach-most-of-DP-problems./177934例题在这：Leetcode198.HouseRobber这类特定的问题可以用下面的顺序来处理：总结递归关系递归（自顶向下）递归+数组（自顶向下）迭代+
  • 谢谢你，包容我的小任性 海隅天玑
    转自兰州大学转载人:黄元香作者:双鱼沐小木前几天，我收到了姐姐的一条消息：国庆想去哪里，给我说，我给你钱！就这样简单的一句话，击碎了我那颗故作坚强的心。图片发自App01我出生的那年，姐姐五岁。五岁那年，恰是在父母怀抱里享受温暖的年纪，却因为我的出现，剥夺了那份本该属于她的的权利。我想，姐姐应该会讨厌我吧！是我的出现，让她脱离了父母的怀抱；是我的出现，让她的童年失去了应有的乐趣；是我的出现，让她遭
  • 一个正经的前端学习 开源 仓库(第1天） 掘金-我是哪吒 javavuehtmlcssjs
    低调务实优秀中国好青年(简介)&&附加答案https://github.com/webVueBlog/Leetcode√-“三十年河东，三十年河西，莫欺少年穷”一个☝️正经的前端学习开源仓库，启发来自淘宝大佬@冴羽，初心做一个真正能帮助到大家的仓库。（非常口语化的，手写总结）：我是哪吒：如果你所学的东西处于喜欢才会有强大的动力支撑。交流讨论&&如何学习&&转载声明第一：你可以直接在本仓库阅读即可，
  • selenium 安装报错问题 weixin_30266829 python
    本机装了py2和py3py2安装selenium总是报错找whl文件也没找到后尝试py3安装selenium成功了/(ఠൠఠ)ﾉ很烦/后来因py3的pip下载了selenium-3.11.0-py2.py3-none-any.whl所以py2的pip也找到了该whl文件直接安装成功/§(*￣▽￣*)§转载于:https://www.cnblogs.com/imaye/p/8794388.html
  • VMware Fusion 13.6 OEM BIOS 2.7 - 在 macOS 中运行 Windows 虚拟机的最佳方式 sysin.org VMwaremacoswindowsfusionoembios虚拟化2025
    VMwareFusion13.6OEMBIOS2.7-在macOS中运行Windows虚拟机的最佳方式VMwareFusion13原版App中集成OEMBIOS请访问原文链接：https://sysin.cn/blog/vmware-fusion-13-oem/，查看最新版。原创作品，转载请保留出处。作者主页：sysin.org2024-09-03，版本13.6更新，支持macOSSequoia作
  • 矩阵求逆（JAVA）初等行变换 qiuwanchi 矩阵求逆（JAVA）
    package gaodai.matrix; import gaodai.determinant.DeterminantCalculation; import java.util.ArrayList; import java.util.List; import java.util.Scanner; /** * 矩阵求逆(初等行变换) * @author 邱万迟 *
  • JDK timer antlove javajdkschedulecodetimer
    1.java.util.Timer.schedule(TimerTask task, long delay)：多长时间（毫秒）后执行任务 2.java.util.Timer.schedule(TimerTask task, Date time)：设定某个时间执行任务 3.java.util.Timer.schedule(TimerTask task, long delay,longperiod
  • JVM调优总结 -Xms -Xmx -Xmn -Xss coder_xpf jvm应用服务器
    堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。 典型设置： java -Xmx
  • JDBC连接数据库 Array_06 jdbc
    package Util; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class JDBCUtil { //完
  • Unsupported major.minor version 51.0（jdk版本错误） oloz java
    java.lang.UnsupportedClassVersionError: cn/support/cache/CacheType : Unsupported major.minor version 51.0 (unable to load class cn.support.cache.CacheType) at org.apache.catalina.loader.WebappClassL
  • 用多个线程处理1个List集合 362217990 多线程threadlist集合
      昨天发了一个提问，启动5个线程将一个List中的内容，然后将5个线程的内容拼接起来，由于时间比较急迫，自己就写了一个Demo，希望对菜鸟有参考意义。。 import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; public c
  • JSP简单访问数据库 香水浓 sqlmysqljsp
    学习使用javaBean，代码很烂，仅为留个脚印 public class DBHelper { private String driverName; private String url; private String user; private String password; private Connection connection; privat
  • Flex4中使用组件添加柱状图、饼状图等图表 AdyZhang Flex
    1.添加一个最简单的柱状图 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 <?xml version= "1.0"&n
  • Android 5.0 - ProgressBar 进度条无法展示到按钮的前面 aijuans android
    在低于SDK < 21 的版本中，ProgressBar 可以展示到按钮前面，并且为之在按钮的中间，但是切换到android 5.0后进度条ProgressBar 展示顺序变化了，按钮再前面，ProgressBar 在后面了我的xml配置文件如下：   [html]  view plain copy   <RelativeLa
  • 查询汇总的sql baalwolf sql
    select   list.listname, list.createtime,listcount from dream_list as list ,   (select listid,count(listid) as listcount  from dream_list_user  group by listid  order by count(
  • Linux du命令和df命令区别 BigBird2012 linux
            1，两者区别             du，disk usage,是通过搜索文件来计算每个文件的大小然后累加，du能看到的文件只是一些当前存在的，没有被删除的。他计算的大小就是当前他认为存在的所有文件大小的累加和。        
  • AngularJS中的$apply，用还是不用？ bijian1013 JavaScriptAngularJS$apply
            在AngularJS开发中，何时应该调用$scope.$apply()，何时不应该调用。下面我们透彻地解释这个问题。         但是首先，让我们把$apply转换成一种简化的形式。         scope.$apply就像一个懒惰的工人。它需要按照命
  • [Zookeeper学习笔记十]Zookeeper源代码分析之ClientCnxn数据序列化和反序列化 bit1129 zookeeper
    ClientCnxn是Zookeeper客户端和Zookeeper服务器端进行通信和事件通知处理的主要类，它内部包含两个类，1. SendThread 2. EventThread， SendThread负责客户端和服务器端的数据通信，也包括事件信息的传输，EventThread主要在客户端回调注册的Watchers进行通知处理   ClientCnxn构造方法   &
  • 【Java命令一】jmap bit1129 Java命令
    jmap命令的用法：   [hadoop@hadoop sbin]$ jmap Usage: jmap [option] <pid> (to connect to running process) jmap [option] <executable <core> (to connect to a
  • Apache 服务器安全防护及实战 ronin47
    此文转自IBM. Apache 服务简介 Web 服务器也称为 WWW 服务器或 HTTP 服务器 (HTTP Server)，它是 Internet 上最常见也是使用最频繁的服务器之一，Web 服务器能够为用户提供网页浏览、论坛访问等等服务。 由于用户在通过 Web 浏览器访问信息资源的过程中，无须再关心一些技术性的细节，而且界面非常友好，因而 Web 在 Internet 上一推出就得到
  • unity 3d实例化位置出现布置？ brotherlamp unity教程unityunity资料unity视频unity自学
    问：unity 3d实例化位置出现布置？ 答：实例化的同时就可以指定被实例化的物体的位置,即 position  Instantiate (original : Object, position : Vector3, rotation : Quaternion) : Object 这样你不需要再用Transform.Position了,   如果你省略了第二个参数(
  • 《重构，改善现有代码的设计》第八章 Duplicate Observed Data bylijinnan java重构
    import java.awt.Color; import java.awt.Container; import java.awt.FlowLayout; import java.awt.Label; import java.awt.TextField; import java.awt.event.FocusAdapter; import java.awt.event.FocusE
  • struts2更改struts.xml配置目录 chiangfai struts.xml
    struts2默认是读取classes目录下的配置文件，要更改配置文件目录，比如放在WEB-INF下，路径应该写成../struts.xml(非/WEB-INF/struts.xml) web.xml文件修改如下：   <filter> <filter-name>struts2</filter-name> <filter-class&g
  • redis做缓存时的一点优化 chenchao051 redishadooppipeline
            最近集群上有个job，其中需要短时间内频繁访问缓存，大概7亿多次。我这边的缓存是使用redis来做的，问题就来了。       首先，redis中存的是普通kv，没有考虑使用hash等解结构，那么以为着这个job需要访问7亿多次redis，导致效率低，且出现很多redi
  • mysql导出数据不输出标题行 daizj mysql数据导出去掉第一行去掉标题
    当想使用数据库中的某些数据，想将其导入到文件中，而想去掉第一行的标题是可以加上-N参数 如通过下面命令导出数据： mysql -uuserName -ppasswd -hhost -Pport -Ddatabase -e " select * from tableName"  > exportResult.txt 结果为： studentid
  • phpexcel导出excel表简单入门示例 dcj3sjt126com PHPExcelphpexcel
    先下载PHPEXCEL类文件，放在class目录下面，然后新建一个index.php文件，内容如下 <?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE);   if (PHP_SAPI == 'cli') die('
  • 爱情格言 dcj3sjt126com 格言
     1) I love you not because of who you are, but because of who I am when I am with you. 　　 我爱你，不是因为你是一个怎样的人，而是因为我喜欢与你在一起时的感觉。 　　2) No man or woman is worth your tears, and the one who is, won‘t
  • 转 Activity 详解——Activity文档翻译 e200702084 androidUIsqlite配置管理网络应用
    activity 展现在用户面前的经常是全屏窗口，你也可以将 activity 作为浮动窗口来使用（使用设置了 windowIsFloating 的主题），或者嵌入到其他的 activity （使用 ActivityGroup ）中。 当用户离开 activity 时你可以在 onPause() 进行相应的操作 。更重要的是，用户做的任何改变都应该在该点上提交 ( 经常提交到 ContentPro
  • win7安装MongoDB服务 geeksun mongodb
    1.  下载MongoDB的windows版本：mongodb-win32-x86_64-2008plus-ssl-3.0.4.zip，Linux版本也在这里下载，下载地址： http://www.mongodb.org/downloads   2.  解压MongoDB在D:\server\mongodb, 在D:\server\mongodb下创建d
  • Javascript魔法方法:__defineGetter__,__defineSetter__ hongtoushizi js
    转载自： http://www.blackglory.me/javascript-magic-method-definegetter-definesetter/ 在javascript的类中,可以用defineGetter和defineSetter_控制成员变量的Get和Set行为 例如,在一个图书类中,我们自动为Book加上书名符号: function Book(name){
  • 错误的日期格式可能导致走nginx proxy cache时不能进行304响应 jinnianshilongnian cache
    昨天在整合某些系统的nginx配置时，出现了当使用nginx cache时无法返回304响应的情况，出问题的响应头： Content-Type:text/html; charset=gb2312 Date:Mon, 05 Jan 2015 01:58:05 GMT Expires:Mon , 05 Jan 15 02:03:00 GMT Last-Modified:Mon, 05
  • 数据源架构模式之行数据入口 home198979 PHP架构行数据入口
    注：看不懂的请勿踩，此文章非针对java，java爱好者可直接略过。   一、概念 行数据入口（Row Data Gateway）：充当数据源中单条记录入口的对象，每行一个实例。   二、简单实现行数据入口 为了方便理解，还是先简单实现： <?php /** * 行数据入口类 */ class OrderGateway { /*定义元数
  • Linux各个目录的作用及内容 pda158 linux脚本
    1）根目录“/” 　　根目录位于目录结构的最顶层，用斜线（/）表示，类似于 Windows 操作系统的“C:\“，包含Fedora操作系统中所有的目录和文件。 　　2）/bin 　　/bin 　　目录又称为二进制目录，包含了那些供系统管理员和普通用户使用的重要 linux命令的二进制映像。该目录存放的内容包括各种可执行文件，还有某些可执行文件的符号连接。常用的命令有：cp、d
  • ubuntu12.04上编译openjdk7 ol_beta HotSpotjvmjdkOpenJDK
    获取源码 从openjdk代码仓库获取(比较慢) 安装mercurial Mercurial是一个版本管理工具。 sudo apt-get install mercurial 将以下内容添加到$HOME/.hgrc文件中，如果没有则自己创建一个： [extensions] forest=/home/lichengwu/hgforest-crew/forest.py fe
  • 将数据库字段转换成设计文档所需的字段 vipbooks 设计模式工作正则表达式
            哈哈，出差这么久终于回来了，回家的感觉真好！         PowerDesigner的物理数据库一出来，设计文档中要改的字段就多得不计其数，如果要把PowerDesigner中的字段一个个Copy到设计文档中，那将会是一件非常痛苦的事情。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他