任未然
任未然

线程池

一、前期知识概要

1、设计模式对象池(资源池)

在我们的日常生活我们听过水池,电池等等,水池了用来存放水,电池用来存放电,而在编程的世界中的池是用来存放一组资源

资源池（resource pool）被认为是一种设计模式，这里的资源主要是指系统资源, 这些资源不专属于某个进程或内部资源。客户端向池请求资源, 并使用返回的资源进行指定的操作。当客户端使用完资源后, 会把资源放回池中而不是释放或丢弃掉。

总结一句话: 需要时,从池中提取,不用时,放回池中

举个栗子: 对象池就想我们公司的仓库，比如我们去公司上班,公司会给我们提供一个工位，行政人员会给我们提供相应的办公设备,那这个时候她首先会看一下库房中，如果库房中有,直接从库房中拿，如果库房中没有,那就会去网上或者商店购买一个新的。如果员工离职了正常情况下会将员工的能用的办公物品放到库房。

image

设计模式

2、应用场景

它用在当对象的初始化过程代价较大或者使用频率较高时，比如线程池,数据库连接池等。运用对象池化技术可以显著地提升性能。

二、为什么要使用

创建线程对象不像其他对象一样在JVM分配内存即可，还要调用操作系统内核的API，然后操作系统为线程分配一系列的资源，这个成本就很高了。所以线程是一个重量级对象，应该避免频繁创建和销毁

降低资源消耗。 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

提高响应速度。 当任务到达时，任务可以不需要的等到线程创建就能立即执行。

提高线程的可管理性。 线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

引用《Java并发编程的艺术》

三、Java线程池的架构设计

1、说明

Java里面线程池的顶级接口是Executor，该类位于java.util.concurrent，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。

2、重要类说明

类或者接口 说明
ExecutorService 真正的线程池接口。
ScheduledExecutorService 定时任务与线程池功能结合使用
ThreadPoolExecutor ExecutorService的默认实现。重点
ScheduledThreadPoolExecutor 周期性任务调度。

3、结构图

image
image

4、Executor

  1. 说明

    Executor接口只有一个execute方法，执行提交Runnable任务，用来替代通常启动线程的方法

  2. 方法

    execute(Runnable r)

  3. 举个栗子

    /*以前*/
Thread t = new Thread();
t.start();

/*使用线程池*/
Thread t = new Thread();
executor.execute(t)

5、ExecutorService

  1. 说明

    ExecutorService接口继承自Executor接口，真正的线程池核心类。提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。增加了shutDown()，shutDownNow()，invokeAll()，invokeAny()和submit()等方法。如果需要支持即时关闭，也就是shutDownNow()方法，则任务需要正确处理中断。

  2. 核心方法

    方法名 返回值 说明
    submit(Callable task) Future 提交一个可运行的任务执行，并返回一个表示该任务结果
    submit(Runable task) Future 提交一个可运行的任务执行，并返回一个表示该任务结果
    shutdown() 布尔 阻止新来的任务提交，对已经提交了的任务不会产生任何影响。当已经提交的任务执行完后，它会将那些闲置的线程进行中断，这个过程是异步的
    shutdownNow() List 设置线程池的状态为STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表
    isShutdown() 布尔 检测线程池是否正处于关闭中
    isTerminated() 布尔 所有任务在关闭后完成，则返回 true 。
    awaitTermination() 布尔 定时或者永久等待线程池关闭结束

  3. 举个栗子

        private static int TASK_COUNT = 10;
    public static void main(String[] args) {
        /*1. 创建线程池对象 */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(5, 8, 1, TimeUnit.SECONDS, new LinkedBlockingDeque<>(5),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy()););
        /*2. 提交任务*/
        for (int i = 0; i < TASK_COUNT; i++) {
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + ":----->在执行任务");
            });
        }
        /*3. 关闭连接池*/
        pool.shutdown();
       /* 或者 */
     // pool.shutdownNow()
    }

6、ScheduledExecutorService

  1. 说明

    ScheduledExecutorService是基于线程池设计的定时任务类，每个调度任务都会分配到线程池中的一个线程去执行，任务是并发执行，互不影响。

  2. 核心方法

  1. 关系图

    image

  2. 示例代码

        public static void main(String[] args) {
        // 创建定时任务线程池
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
        //设置日期格式
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
             // 提交一个任务两秒之后开始执行
        executorService.schedule(() -> {
            System.out.println("++++++++++++++++++++子线程:" + df.format(new Date()));
        }, 2, TimeUnit.SECONDS);
        System.out.println("主线程:    " + df.format(new Date()));
//        executorService.shutdown();
    }

7、工作流程(了解)

image

四、线程池的状态与生命周期

1、概要

线程池有运行、关闭、停止、清空状态、结束五种状态，结束后就会释放所有资源

  1. RUNNING(运行): 接受新的任务和处理队列中的任务
  2. SHUTDOWN(关闭): 不接受新的请求,但会处理已经添加到队列中的任务
  3. STOP(停止): 不接收新任务，也不处理队列任务，并且中断所有处理中的任务。
  4. TIDYING(整理):所有任务都被终结，有效线程为0。会触发terminated()方法
  5. TERMINATED(结束):当terminated()方法执行结束

2、流程图

image

五、ThreadPoolExecutor

1、线程池的创建

  1. 构造方法

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

2、参数概要

参数 概要
corePoolSize 池中所保存的线程数，包括空闲线程。
maximumPoolSize 池中允许的最大线程数。
keepAliveTime 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
unit - keepAliveTime 时间单位。
workQueue 执行前用于保持任务的队列。此队列仅保持由 execute方法提交的 Runnable任务。
threadFactory 执行程序创建新线程时使用的工厂
handler 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。

3、参数详解

3.1、corePoolSize（必要参数）

核心线程数。默认情况下，核心线程会一直存活，但是当将allowCoreThreadTimeout设置为true时，核心线程也会超时回收。

3.2、maximumPoolSize(必要参数)

线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列这个参数就没什么效果。

3.3、keepAliveTime(必要参数)

线程池的工作线程空闲后，保持存活的时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率。

3.4、unit(必要参数)

指定keepAliveTime参数的时间单位

可选值 说明
TimeUnit.DAYS 天
TimeUnit.HOURS 小时
TimeUnit.MINUTES(常用) 分钟
TimeUnit.SECONDS(常用) 秒
TimeUnit.MILLISECONDS(常用) 毫秒
TimeUnit.MICROSECONDS 微秒(千分之一毫秒)
TimeUnit.NANOSECONDS 毫微秒(千分之一微秒)

3.5、workQueue

任务队列。Runnable对象就存储在该参数中

3.6、threadFactory(可选)

线程工厂。用于指定为线程池创建新线程的方式

3.7、handler(可选)

  1. 说明

    拒绝策略。有两种情况会触发拒绝策略

    • 队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是 AbortPolicy，表示无法处理新任务时抛出异常
    • 当线程池被调用shutdown()后

  2. 可选值

    策略 说明
    AbortPolicy 直接抛出异常。默认值
    CallerRunsPolicy 只用调用者所在线程来运行任务。
    DiscardOldestPolicy 丢弃队列里最近的一个任务，并执行当前任务。
    DiscardPolicy 不处理，丢弃掉。

4、举个栗子

  1. 有返回值

     public static void start() {
        /*
         * 创建线程池，并发量最大为5
         * LinkedBlockingDeque，表示执行任务或者放入队列
         */
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 0,
                TimeUnit.SECONDS, new LinkedBlockingDeque<>());
        // 存储线程的返回值
        List> results = new LinkedList<>();
        for (int i = 0; i < 10; i++) {
            // 调用submit可以获得线程的返回值
            int num = i;
            Future result = executor.submit(() -> num + "");
            results.add(result);
        }
        //如果不调用，awaitTermination将一直阻塞
        executor.shutdown();
        //1天，模拟永远等待
        try {
            System.out.println(executor.awaitTermination(1, TimeUnit.DAYS));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        //输出结果
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println(results.get(i).get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

5、corePoolSize、workQueue 、maximumPoolSize的关系

  1. 默认情况下，线程池在初始的时候，线程数为0。当接收到一个任务时，如果线程池中存活的线程数小于corePoolSize核心线程，则新建一个线程。
  2. 如果所有运行的核心线程都都在忙，超出核心线程处理的任务，执行器更多地选择把任务放进队列，而不是新建一个线程。
  3. 如果一个任务提交不了到队列，在不超出最大线程数量情况下，会新建线程。就根据指定的拒绝策略来处理,默认抛出异常。
  4. 如线程闲置时，线程池会根据keepAliveTime设置的时间回收大于corePoolSize的线程

六、ScheduledThreadPoolExecutor

1、简介

ScheduledThreadPoolExecutor用来执行周期性任务的调度。在这之前的实现需要依靠Timer和TimerTask或者其它第三方工具来完成。它主要有以下两个作用

  1. 延时执行任务。
  2. 周期性重复执行任务。
Timer ScheduledThreadPoolExecutor
单线程 多线程
单个任务执行时间影响其他任务调度 多线程，不会影响
基于绝对时间 基于相对时间
一旦执行任务出现异常不会捕获，其他任务得不到执行 多线程，单个任务的执行不会影响其他线程

2、示例代码

  1. 执行一次
    private static final int TASK_COUNT = 3;

    public static void main(String[] args) throws InterruptedException {
        // 创建大小为2的线程池
        ScheduledExecutorService scheduledThreadPool = new ScheduledThreadPoolExecutor(2);
        for (int i = 0; i < TASK_COUNT; i++) {
            // 只执行一次
          scheduledThreadPool.schedule(() -> {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, 5, TimeUnit.SECONDS);

        }

        // 关闭线程池
        scheduledThreadPool.shutdown();
        boolean isStop;
        // 等待线程池终止
        do {
            isDone = scheduledThreadPool.awaitTermination(1, TimeUnit.HOURS);
            System.out.println("等待任务结束中...");
        } while (!isStop);
        System.out.println("所有工作完成!!! 线程池关闭");
    }

  1. 周期执行任务

        private static final int TASK_COUNT = 3;

    public static void main(String[] args) throws InterruptedException {
        // 1. 创建大小为2的线程池
        ScheduledExecutorService scheduledThreadPool = new ScheduledThreadPoolExecutor(2);
            // 2. 周期性执行，每2秒执行一次
            scheduledThreadPool.scheduleAtFixedRate(() -> {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, 0, 2, TimeUnit.SECONDS);
        }

        // 3.关闭线程池
        scheduledThreadPool.shutdown();
        boolean isStop;
        // 等待线程池终止
        do {
            isStop = scheduledThreadPool.awaitTermination(1, TimeUnit.HOURS);
            System.out.println("等待任务结束中...");
        } while (!isStop);
         System.out.println("所有工作完成!!! 线程池关闭");
    }

七、任务队列

1、名词解释

1.1、什么叫有界

有界就是有固定大小的队列，无界表示无上限

1.2、什么叫队列

Queue 一个队列就是一个先入先出（FIFO）的数据结构

Queue接口与List、Set同一级别，都是继承了Collection接口。

2、常用队列

2.1、ArrayBlockingQueue

  1. 作用

    采用数组实现的有界阻塞线程安全队列。如果向已满的队列继续塞入元素，将导致当前的线程阻塞。如果向空队列获取元素，那么将导致当前线程阻塞。

  2. 构造方法

    构造方法 参数说明
    public ArrayBlockingQueue(int capacity) 构造指定大小的有界队列
    public ArrayBlockingQueue(int capacity, boolean fair) 构造指定大小的有界队列，指定为公平或非公平锁
    public ArrayBlockingQueue(int capacity, boolean fair, Collection c) 构造指定大小的有界队列，指定为公平或非公平锁，指定在初始化时加入一个集合

  3. 示例代码

    public class ArrayBlockingQueueExample {
    public static final int COUNT = 100;

    public static void main(String[] args) throws Exception {
        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(10);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 8, 60, TimeUnit.SECONDS, queue);
        for (int i = 0; i < COUNT; i++) {
            TimeUnit.SECONDS.sleep(1);
            executor.execute(() ->
                    System.out.println("线程池---数组实现的有界阻塞线程安全队列" + Thread.currentThread().getName()));
        }
        executor.shutdown();
    }
}

2.2、LinkedBlockingQueue

  1. 作用

    一个由链表结构组成的有界阻塞队列(也可以当无界阻塞队列)。此队列按 FIFO（先进先出）原则。Executor.newFixedThreadPool()默认队列

  2. 构造方法

    构造方法 参数说明
    public LinkedBlockingQueue() 在未指明容量时，容量默认为Integer.MAX_VALUE
    public LinkedBlockingQueue(int capacity) 构造指定大小的有界队列

2.3、SynchronousQueue;

  1. 作用

    一个不存储元素的有界阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool()使用了这个队列。

  2. 构造方法

    构造方法 参数说明
    public SynchronousQueue() 默认情况下不保证排序,
    public SynchronousQueue(boolean fair) 如果设置true队列可保证线程以 FIFO 的顺序进行访问

  3. 示例代码

    public class SynchronousQueueExample {
    public static final int COUNT = 100;

    public static void main(String[] args) {
        SynchronousQueue queue = new SynchronousQueue<>();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, Integer.MAX_VALUE, 1, TimeUnit.SECONDS, queue);
        for (int i = 0; i < COUNT; i++) {
            executor.execute(() ->
                    System.out.println("线程池---同步队列" + Thread.currentThread().getName()));
        }
        executor.shutdown();
    }
}

  4. 分析

    • 假设当前有2个核心线程

    • 此时来了一个任务（A），根据前面介绍的“如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。”,所以A被添加到queue中。

    • 又来了一个任务（B），且核心2个线程还没有忙完。接下来首先尝试1中描述，但是由于使用的SynchronousQueue，所以一定无法加入进去。

    • 此时便满足了上面提到的“如果无法将请求加入队列，则创建新的线程”，所以必然会新建一个线程来运行这个任务。

    • 但是如果这三个任务都还没完成，继续来了一个任务，queue中无法插入（任务A还在queue中），而线程数达到了maximumPoolSize，所以只好执行异常策略了。
      为了避免这种情况:，所以在使用SynchronousQueue通常要求maximumPoolSize是无界的（如果希望限制就直接使用有界队列）。对于使用SynchronousQueue的作用jdk中写的很清楚：此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。

2.4、PriorityBlockingQueue

  1. 作用

    一种优先级队列，元素并不是以FIFO的方式出/入队。默认大小为11，不可以插入 null 值。当队列满的时候会进行扩容,是真正意义上的无界(仅受内存大小限制)，它不像ArrayBlockingQueue那样构造时必须指定最大容量，也不像LinkedBlockingQueue默认最大容量为Integer.MAX_VALUE；

  2. 构造方法

    构造方法 参数说明
    PriorityBlockingQueue()
    PriorityBlockingQueue(int initialCapacity) 指定初始化队列长度
    PriorityBlockingQueue(int initialCapacity, Comparator comparator) 指定初始化队列长度,自定义比较器

  3. 示例代码

八、Executors(了解)

1、说明

对于新手来说要配置一个线程池还是比较有难度的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池

2、注意注意注意

image

3、Executors静态方法

1、newSingleThreadExecutor

  1. 作用

    创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。

  2. 方法

    Executors.newSingleThreadExecutor()

  3. 应用场景

    保证所有任务的执行顺序按照任务的提交顺序执行

    不适合并发但可能引起IO阻塞性及影响UI线程响应的操作，如数据库操作、文件操作等

2、newFixedThreadExecutor

  1. 作用

    创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程

  2. 方法

    Executors.newFixedThreadExecutor()

  3. 应用场景

    控制线程最大并发数

  4. 举个栗子

3、newCacheThreadExecutor

  1. 作用

    创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，

    那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小

  2. 方法

    Executors.newCacheThreadExecutor()

  3. 应用场景

    适合执行大量、耗时少的任务

  4. 举个栗子

4、newScheduleThreadExecutor

  1. 作用

    创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求

  2. 方法

    Executors.newScheduleThreadExecutor()

  3. 示例代码

    // 1. 创建 定时线程池对象 & 设置线程池线程数量固定为5
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
 public void run() {
 System.out.println("执行任务啦");
 }
};
// 3. 向线程池提交任务
scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 延迟1s后执行任务
scheduledThreadPool.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);// 延迟10ms后、每隔1000ms执行任务

九、面试题

1、shutdown

  1. shutdown()有什么作用？

阻止新来的任务提交,对已经提交的任务不会产生任何影响 当已经提交的任务执行完成之后,那些闲置的线程会被回收
这个过程是异步的。

  1. 如何阻止新来的任务提交？

通过将线程池的状态改成SHUTDOWN，当再将执行execute提交任务时，如果测试到状态不为RUNNING，则抛出rejectedExecution，从而达到阻止新任务提交的目的。

  1. 为何对提交的任务不产生任何影响？

在调用中断任务的方法时，它会检测workers中的任务，如果worker对应的任务没有中断，并且是空闲线程，它才会去中断。另外的话，workQueue中的值，还是按照一定的逻辑顺序不断的往works中进行输送的，这样一来，就可以保证提交的任务按照线程本身的逻辑执行，不受到影响。

2、shutdownNow

  1. shutdownNow()有什么功能？

    阻止新来的任务提交，同时会中断当前正在运行的线程，即workers中的线程。另外它还将workQueue中的任务给移除，并将这些任务添加到列表中进行返回。

  2. 如何阻止新来的任务提交？

    通过将线程池的状态改成STOP，当再将执行execute提交任务时，如果测试到状态不为RUNNING，则抛出rejectedExecution，从而达到阻止新任务提交的目的.

  3. 如果我提交的任务代码块中，正在等待某个资源，而这个资源没到，但此时执行shutdownNow()，会出现什么情况？

    当执行shutdownNow()方法时，如遇已经激活的任务，并且处于阻塞状态时，shutdownNow()会执行1次中断阻塞的操作，此时对应的线程报InterruptedException，如果后续还要等待某个资源，则按正常逻辑等待某个资源的到达。例如，一个线程正在sleep状态中，此时执行shutdownNow()，它向该线程发起interrupt()请求，而sleep()方法遇到有interrupt()请求时，会抛出InterruptedException()，并继续往下执行。在这里要提醒注意的是，在激活的任务中，如果有多个sleep(),该方法只会中断第一个sleep()，而后面的仍然按照正常的执行逻辑进行。

附: 线程池工具类

public class ThreadPoolUtil {
    /**
     * 核心线程池大小
     */
    private static final int CORE_POOL_SIZE = 20;

    /**
     * 最大可创建的线程数
     */
    private static final int MAX_POOL_SIZE = 100;

    /**
     * 线程池维护线程所允许的空闲时间
     */
    private static final int KEEP_ALIVE_SECONDS = 5;

    /**
     * 队列最大长度
     */
    private static final int QUEUE_CAPACITY = 1000;

    public volatile static ExecutorService pool;

    /**
     * 获取线程池
     * @return
     */
    public static ExecutorService getPool(){
        if(null == pool){
            synchronized (ThreadPoolUtil.class) {
                if (null == pool) {
                    pool = new ThreadPoolExecutor(
                            CORE_POOL_SIZE,
                            MAX_POOL_SIZE,
                            KEEP_ALIVE_SECONDS,
                            TimeUnit.SECONDS,
                            new LinkedBlockingDeque<>(QUEUE_CAPACITY),
                            Executors.defaultThreadFactory(),
                            new ThreadPoolExecutor.CallerRunsPolicy());
                }
            }
        }
        return pool;
    }

    /**
     * 获取线程池
     * @return
     */
    public static ExecutorService getPoolNew(){
        if(null == pool){
            synchronized (ThreadPoolUtil.class) {
                if (null == pool) {
                    /**
                     * 1. 缓存线程池
                     * {@Code Executors.newCachedThreadPool()}
                     * corePoolSize=0, maxinumPoolSize=+∞，队列长度=0 ，
                     * 因此线程数量会在corePoolSize到maxinumPoolSize之间一直灵活缓存和变动，
                     * 且不存在队列等待的情况，一来任务我就创建，用完了会释放。
                     *
                     * 2. 定长线程池
                     * {@Code Executors.newFixedThreadPool()}
                     * corePoolSize= maxinumPoolSize=构造参数值， 队列长度=+∞。因此不存在线程不够时扩充的情况
                     *
                     * 3. 定时器线程池
                     * {@Code Executors.newScheduledThreadPool()}
                     * 提交定时任务用的，构造参数里会带定时器的间隔和单位。 其他和FixedThreadPool相同，属于定长线程池。
                     *
                     * 4. 单线程池
                     * {@Code Executors.newScheduledThreadPool()}
                     * corePoolSize=maxinumPoolSize=1， 队列长度=+∞，只会跑一个任务， 所以其他的任务都会在队列中等待，因此会严格按照FIFO执行
                     */
                    pool = Executors.newFixedThreadPool(50);
                }
            }
        }
        return pool;
    }

    /**
     * 执行线程(无返回值)
     */
    public static void execute(ThreadExecuteTask threadExecuteTask,Object... objects){
        ExecutorService pool = getPool();
        pool.execute(() -> {
            threadExecuteTask.execute(objects);
        });
    }

    /**
     * 执行线程(有返回值)
     */
    public static  Future submit(ThreadSubmitTask threadSubmitTask,Object... objects){
        ExecutorService pool = getPool();
        Future future = pool.submit(() -> {
            return threadSubmitTask.submit(objects);
        });
        return future;
    }
}

interface ThreadExecuteTask{
    /**
     * 无返回值方法
     * @param objects
     */
    void execute(Object... objects);
}

interface ThreadSubmitTask{
    /**
     * 有返回值方法
     * @param objects
     * @return
     */
    T submit(Object... objects);
}

你可能感兴趣的:(线程池)

  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • Spring @Async 深度解读：默认线程池执行器的配置与优化 小码快撩 springjava前端
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • Java 并发编程：Java 线程池的介绍与使用 栗筝i 栗筝i的Java技术栈#Java基础栗筝i的Java技术栈Java基础Java并发Java线程池
    大家好，我是栗筝i，这篇文章是我的“栗筝i的Java技术栈”专栏的第024篇文章，在“栗筝i的Java技术栈”这个专栏中我会持续为大家更新Java技术相关全套技术栈内容。专栏的主要目标是已经有一定Java开发经验，并希望进一步完善自己对整个Java技术体系来充实自己的技术栈的同学。与此同时，本专栏的所有文章，也都会准备充足的代码示例和完善的知识点梳理，因此也十分适合零基础的小白和要准备工作面试的同
  • java 线程池 队列封装_java线程池（线程池组---分离任务队列和线程池） 爱打怪的小魔女 java线程池队列封装
    线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
  • 线程池的应用--＞1 路ZP java开发语言
    1.线程的执行机制线程分为用户线程和内核线程内核线程就是系统级别的线程，与cpu逻辑处理器数量对应的用户线程就是使用java代码创建的Thread对象用户线程必须与内核线程关联（映射），才能执行任务当用户线程多于内核线程时，内核线程就需要不停的上下文切换，使得多个用户线程都能得以执行上下文会影响性能，消耗资源。大量的创建用户线程，消耗用户线程，也会影响性能，消耗资源。所以我们希望，创建合适数量的线
  • Java 中自定义线程池 胡英俊俊俊 #JUCjava开发语言
    Java中自定义线程池的方式在Java开发中，线程池是非常常用的工具，它能够帮助我们更好地管理多线程任务，提升并发性能并避免过度创建线程导致的系统资源消耗。在Java中，线程池主要由ThreadPoolExecutor提供，该类支持自定义线程池的核心参数，如线程数、任务队列以及拒绝策略等。在这篇文章中，我们将讨论如何通过ThreadPoolExecutor来实现自定义线程池，以及常用的配置和使用方
  • Hystrix&Feign 快乐肥翟z hystrixjava运维
    Hystrix1，概念Hystrix是一个用于处理分布式系统的延迟和容错的开源库，可以保证一个服务出现故障时，不会导致整个系统出现雪崩效应，以提高分布式系统弹性；作为“断路器”，在一个服务出现故障时，可以通过短路器监控，返回一个可以处理的响应结果，保证服务调用线程不会长时间被占用，避免故障蔓延。雪崩当一个服务器中要同时处理多个请求时，当一个请求无法正确响应，请求超时。会将请求阻塞到该服务的线程池中
  • 知乎获2000赞的Java 多线程超详细总结笔记，看这一篇彻底搞懂线程池 Java老猿 Java多线程面试java程序人生阿里巴巴
    一、多线程有什么用？一个可能在很多人看来很扯淡的一个问题：我会用多线程就好了，还管它有什么用？在我看来，这个回答更扯淡。所谓"知其然知其所以然"，“会用"只是"知其然”，“为什么用"才是"知其所以然”，只有达到"知其然知其所以然"的程度才可以说是把一个知识点运用自如。OK，下面说说我对这个问题的看法：（1）发挥多核CPU的优势随着工业的进步，现在的笔记本、台式机乃至商用的应用服务器至少也都是双核的
  • 手写Tomcat Fix12138
    需求分析根据Tomcat的基本功能分析，基本需求包括：监听端口，接受外部请求多线程并发处理多个请求解析HTTP请求，根据URL找到对应的Servlet扫描Web目录，解析web.xml配置，加载开发者实现的Servlet类，生成对象并调用其service方法得到response返回给客户端代码实现接受请求的服务端通过scoket监听端口，将接受到的请求提交到线程池处理。线程池中的任务为具体的处理逻
  • Java Executors类的9种创建线程池的方法及应用场景分析 工业甲酰苯胺 java开发语言
    在Java中，Executors类提供了多种静态工厂方法来创建不同类型的线程池。在学习线程池的过程中，一定避不开Executors类，掌握这个类的使用、原理、使用场景，对于实际项目开发时，运用自如，以下是一些常用的方法，一一细说：newCachedThreadPool():创建一个可缓存的线程池，如果线程池中的线程超过60秒没有被使用，它们将被终止并从缓存中移除。newFixedThreadPoo
  • Qt线程池--面试必备 超级哇塞 CuteeQtqt开发语言
    Qt的线程池是一个非常强大的工具，用于管理和调度线程任务。使用线程池可以有效地实现并发处理，提升应用程序的性能，尤其是在需要执行大量异步任务时。###线程池概述线程池是一种预先创建一定数量的线程并将它们放入池中，供后续任务使用的机制。通过使用线程池，应用程序可以减少线程的创建和销毁开销，同时控制并发任务的数量，从而提高性能和资源利用率。###Qt的线程池实现在Qt中，`QThreadPool`和`
  • 线程池的应用--＞2 路ZP javajvm开发语言
    1.自定义线程工程当需要自定义线程的名字，线程的优先级，精灵线程状态时，需要自定义线程工厂。如何自定义线程工厂自定义工厂类，实现ThreadFactory接口，重写方法newThread()在创建线程池对象时，传递上述线程工厂对象publicclassTest5{publicstaticvoidmain(String[]args){System.out.println("-------------
  • 【多线程服务器】多线程下网络编程 gma999 c++服务器
    目录多线程模型-非阻塞IO+oneloopperthreadoneloopperthread线程池oneloopperthread与线程池结合目前主流多线程模型Reactor模式+线程池Proactor模式Master-Worker模型多线程编程的实现线程抢占问题Happens-Before关系Linux下多线程编程常用函数线程的创建线程销毁多线程下的I/ORAII与文件描述符管理RAII与for
  • 多线程与线程池的理解 Ronaldinho Gaúch 后端java
    线程操作系统能够运算调度的最小单位，被包含于进程直至，是进程的实际运作单位进程程序基本执行实体可以这么理解，微信是一个进程，里面的朋友圈和视频号为线程，即软件中互相独立，可以同时运行的功能，若该软件中独立的功能很多，那就是多线程多线程实现原理：利用CPU等待的空闲时间在不同程序间进行切换线程池存放线程的容器当线程池为空时，若有任务需要完成，线程池会自动生成一个线程，以该线程去执行任务，执行完了该线
  • Java 中的 ExecutorService 与线程池管理 项目笔记与工具库 javapythonspring
    在多线程编程中，频繁地创建和销毁线程是一项非常耗费资源的操作。为了更高效地管理并发任务，Java提供了线程池机制，尤其是通过ExecutorService接口。线程池可以复用已经创建的线程，降低系统资源消耗，从而提升应用的性能和稳定性。本文将讲解ExecutorService的核心功能、常用的线程池实现，以及如何优化线程池的使用。1.什么是ExecutorService？ExecutorServi
  • 跨线程参数传递TransmittableThreadLocal 小玉起起 javajucjava开发语言
    TransmittableThreadLocal是阿里巴巴开源的transmittable-thread-local库提供的一个类，它是ThreadLocal的一个增强版本，主要用于解决跨线程传递ThreadLocal变量值的问题。通常情况下，ThreadLocal变量的值只能在当前线程中共享，而无法在线程之间传递。但在一些特殊情况下，比如使用线程池时，任务可能会在不同的线程中执行，这时就需要一种
  • golang线程池ants-四种使用方法 liupenglove golang后端多线程
    目录1、ants介绍2、使用方式汇总3、各种使用方式详解3.1默认池3.2普通模式3.3带参函数3.4多池多协程4、总结1、ants介绍众所周知，goroutine相比于线程来说，更加轻量、资源占用更少、无线程上下文切换等优势，但是也不能无节制的创建使用，如果系统中开启的goroutine过多而没有及时回收，也会造成系统内存资源耗尽。ants是一款高性能的协程管理池，实现了协程的创建、缓存、复用、
  • ThreadPoolExecutor常用方法 君子剑mango java开发语言后端
    一线程池中线程数量ThreadPoolExecutor类中线程数量相关方法publicintgetCorePoolSize()：thecorenumberofthreads，核心线程数，固定值；publicintgetMaximumPoolSize()：themaximumallowednumberofthreads，最大线程数，固定值；publicintgetPoolSize()：thecurr
  • 面试官：如何实现线程池任务编排？ 工业甲酰苯胺 java前端算法
    任务编排（TaskOrchestration）是指管理和控制多个任务的执行流程，确保它们按照预定的顺序正确执行。1.为什么需要任务编排？在复杂的业务场景中，任务间通常存在依赖关系，也就是某个任务会依赖另一个任务的执行结果，在这种情况下，我们需要通过任务编排，来确保任务按照正确的顺序进行执行。例如，以下任务的执行顺序：其中，任务二要等任务一执行完才能执行，而任务四要等任务二和任务三全部执行完才能执行
  • 【C-实践】文件服务器（4.0） 轩轶子 #C语言实践c语言服务器开发语言
    文件服务器1.0文件服务器2.0文件服务器3.0概述使用了tcp+epoll+线程池+生产者消费者模型，实现文件服务器有两个进程，主进程负责接收退出信号用来退出整个程序；子进程负责管理线程池、客户端连接以及线程池的退出子进程中的主线程生产任务，其他子线程消费任务与3.0的区别是线程池的退出方式，在收到退出信号后，通知线程池让它们自己退出。3.0是暴力退出线程池，4.0是温和退出线程池在任务队列中新
  • ThreadLocal 释放的方式有哪些 程序猿进阶 Java并发编程（多线程）java开发语言并发编程ThreadLocal线程池架构性能优化
    ThreadLocal基础概念：IT-BLOG-CNThreadLocal是Java中用于在同一个线程中存储和隔离变量的一种机制。通常情况下，我们使用ThreadLocal来存储线程独有的变量，并在任务完成后通过remove方法清理这些变量，以防止内存泄漏。然而，在使用线程池时，线程会被重用，这可能导致ThreadLocal变量未被及时清理，从而引发内存泄漏问题。除了直接调用ThreadLocal
  • Java 如何获取线程状态呢? qq_25073223 多线程javajava
    下文笔者讲述Java中获取线程状态的方法分享,如下所示:java线程状态的简介Java中的线程整个生命周期中分为5种状态:1.新建状态(New):新建的线程都为此状态2.就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法该状态的线程在"可运行线程池"中,是可运行,一旦获得CPU权限,则立即运行3.运行状态(Running):已经取得CPU权限,并执行代码4.阻塞
  • JAVA中的线程池说明一 Petrichor-瑾 JavaEEjava开发语言
    系列文章JAVA中的线程池说明一JAVA中的线程池说明二目录1.为什么需要线程池?2.什么是线程池?3.标准库中的线程池4.实现自定义线程池1.为什么需要线程池?线程的存在意义在于解决并发编程中进程开销过大的问题，因此引入了线程，也被称为"轻量级线程"。相比于创建进程，创建线程更加高效；同样地，销毁线程比销毁进程更高效，调度线程比调度进程更高效。在许多情况下，使用多线程可以替代进程来实现并发编程。
  • 常见的设计模式 学Java的skyyyyyyyy 设计模式java单例模式
    设计模式是面向对象设计中解决常见问题的一套最佳实践，它们为开发者提供了通用的解决方案。1.单例模式（SingletonPattern）定义：确保一个类只有一个实例，并提供一个全局访问点。应用场景：需要控制实例数量的类，如数据库连接池、线程池等。需要共享的全局状态或资源的类。实现方式：饿汉式：在类加载时就创建实例，线程安全但可能会造成资源浪费。懒汉式：在第一次调用时创建实例，需考虑线程安全问题。双重
  • Elasticsearch——配置详解 smart哥 elasticsearch专题elasticsearch搜索引擎
    作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！阶段1、深入多线程阶段2、深入多线程设计模式阶段3、深入juc源码解析阶段4、深入jdk其余源码解析阶段5、深入jvm源码解析码哥源码部分码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场
  • windows C++-并行编程-并行模式库 (PPL) sului windowsC++并行编程技术c++开发语言windows
    并行模式库(PPL)提供命令式编程模型，以促进开发并发应用程序的可扩展性和易用性。PPL构建在并发运行时的计划和资源管理组件上。通过提供并行作用于数据的泛型安全算法和容器，提高应用程序代码与基础线程机制之间的抽象级别。使用PPL还可以开发通过为共享状态提供替代方案实现缩放的应用程序。PPL提供以下功能：任务并行：基于Windows线程池来并行执行多个工作项（任务）的机制并行算法：基于并发运行时来并
  • RocketMQ 如何保证消息不丢失？ JinYD2018 #RocketMQjava-rocketmqrocketmqjava
    RocketMQ的消息想要确保不丢失，需要生产者、消费者以及Broker的共同努力，缺一不可。生产者（Producer）1、发送方式：选择同步发送同步发送：发送消息后，需要阻塞等待Broker确认收到消息，生产者才能拿到返回的SendResult异步发送：Producer首先构建一个向broker发送消息的任务，把该任务提交给线程池，等执行完该任务时，回调用户自定义的回调函数，执行处理结果。2、重
  • Android中的线程（一） 川峰 Android知识笔记android多线程线程安全线程池线程通信
    本文主要是对Android当中的线程相关的知识进行复习和总结。文章目录newThreadAsyncTaskHandlerThreadIntentServiceJobIntentServiceJobSchedulerWorkManager线程中断守护线程线程优先级线程状态线程池线程安全线程通信kotlin协程newThread缺乏统一管理，无限制创建，可能占用过多系统资源导致死机或oom，不推荐。A
  • Java线程池 sparkle123
    Callable和Runable都是启动一个线程,不过Callable可以有返回值importjava.util.concurrent.{Callable,Executor,Executors,Future}objectThreadDemo{defmain(args:Array[String]):Unit={valpool=Executors.newFixedThreadPool(5)//for(
  • 辗转相处求最大公约数 沐刃青蛟 C++漏洞
    无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！   为此，总结一下以方便日后忘了好查找。   1.输入要比较的两个数a,b   忽略：2.比较大小（因为后面要的是大的数对小的数做%操作）   3.辗转相除（用循环不停的取余，如a%b,直至b=0）   4.最后的a为两数的最大公约数 &
  • F5负载均衡会话保持技术及原理技术白皮书 bijian1013 F5负载均衡
    一.什么是会话保持？        在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
  • Object.equals方法：重载还是覆盖 Cwind javagenericsoverrideoverload
    本文译自StackOverflow上对此问题的讨论。 原问题链接   在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： “不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” pu
  • 初始线程 15700786134
          暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。            既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： public class ShapeFr
  • Linux的tcpdump 被触发 tcpdump
    用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支 持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。 实用命令实例 默认启动 tcpdump 普通情况下，直
  • 安卓程序listview优化后还是卡顿 肆无忌惮_ ListView
    最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 &nb
  • 扩展easyUI tab控件，添加加载遮罩效果 知了ing jquery
    (function () { $.extend($.fn.tabs.methods, { //显示遮罩 loading: function (jq, msg) { return jq.each(function () { var panel = $(this).tabs(&
  • gradle上传jar到nexus 矮蛋蛋 gradle
    原文地址： https://docs.gradle.org/current/userguide/maven_plugin.html configurations {     deployerJars } dependencies {     deployerJars "org.apache.maven.wagon
  • 千万条数据外网导入数据库的解决方案。 alleni123 sqlmysql
    从某网上爬了数千万的数据，存在文本中。 然后要导入mysql数据库。 悲剧的是数据库和我存数据的服务器不在一个内网里面。。 ping了一下， 19ms的延迟。 于是下面的代码是没用的。 ps = con.prepareStatement(sql); ps.setString(1, info.getYear())............; ps.exec
  • JAVA IO InputStreamReader和OutputStreamReader 百合不是茶 JAVA.io操作 字符流
    这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！： JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流   字节流和字符的难点：a,怎么将读到的数据
  • MO、MT解读 bijian1013 GSM
    MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息； 上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
  • 五个JavaScript基础问题 bijian1013 JavaScriptcallapplythisHoisting
    下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。 问题1：Scope作用范围 考虑下面的代码：  (function() { var a = b = 5; })(); console.log(b); 什么会被打印在控制台上？  回答：         上面的代码会打印 5。 &nbs
  • 【Thrift二】Thrift Hello World bit1129 Hello world
    本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程   1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 <dependency>
  • 【Avro一】Avro入门 bit1129 入门
    本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。   1. 添加Maven依赖   <?xml version="1.0" encoding="UTF-8"?> <proj
  • 安装nginx+ngx_lua支持WAF防护功能 ronin47
    需要的软件:LuaJIT-2.0.0.tar.gz                   nginx-1.4.4.tar.gz          &nb
  • java-5.查找最小的K个元素-使用最大堆 bylijinnan java
    import java.util.Arrays; import java.util.Random; public class MinKElement { /** * 5.最小的K个元素 * I would like to use MaxHeap. * using QuickSort is also OK */ public static void
  • TCP的TIME-WAIT bylijinnan socket
    原文连接： http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 以下为对原文的阅读笔记 说明： 主动关闭的一方称为local end，被动关闭的一方称为remote end 本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 1、TIME_WA
  • jquery ajax 序列化表单 coder_xpf Jquery ajax 序列化
       checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值   <input type="checkbox" name="favor" id="favor" checked="checked"/> $("#favor&quo
  • Apache集群乱码和最高并发控制 cuisuqiang apachetomcat并发集群乱码
    都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。 最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： <Connector maxThreads="300" port="8019" prot
  • websocket dalan_123 websocket
    一、低延迟的客户端-服务器 和 服务器-客户端的连接 很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。   通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
  • 菜鸟分析网络执法官 dcj3sjt126com 网络
      最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 前面我们看到了.在以太网上传输的都是具有以太网头的数据包. 
  • Android相对布局属性全集 dcj3sjt126com android
    RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 // 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
  • Tomcat内存设置详解 eksliang jvmtomcattomcat内存设置
    Java内存溢出详解   一、常见的Java内存溢出有以下三种：   1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。 可以利用JVM提
  • Java6 JVM参数选项 greatwqs javaHotSpotjvmjvm参数JVM Options
    Java 6 JVM参数选项大全（中文版）   作者：Ken Wu Email: [email protected] 转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！   本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
  • weblogic创建JMC i5land weblogicjms
    进入 weblogic控制太 1.创建持久化存储 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 2.创建JMS服务器 --Services--Messaging--JMS Servers--new--name随便起--Pers
  • 基于 DHT 网络的磁力链接和BT种子的搜索引擎架构 justjavac DHT
    上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。 系统包括几个独立的部分： 使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子； 使用 PHP CI 框架开发的简易网站； 搜索引擎目前直接使用的 MySQL，将来可以考虑使
  • sql添加、删除表中的列 macroli sql
    添加没有默认值：alter table Test add BazaarType char(1) 有默认值的添加列：alter table Test add BazaarType char(1) default(0) 删除没有默认值的列：alter table Test drop COLUMN BazaarType 删除有默认值的列：先删除约束（默认值）alter table Test DRO
  • PHP中二维数组的排序方法 abc123456789cba 排序二维数组PHP
    <?php/*** @package     BugFree* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level
  • hive优化之------控制hive任务中的map数和reduce数 superlxw1234 hivehive优化
    一、    控制hive任务中的map数: 1.    通常情况下，作业会通过input的目录产生一个或者多个map任务。 主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2. 
  • Spring Boot 1.2.4 发布 wiselyman spring boot
    Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。   这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。   Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他