Java并发编程-线程池(01)

最新推荐文章于 2024-08-23 00:00:00 发布
最新推荐文章于 2024-08-23 00:00:00 发布
阅读量1.2k 收藏 19
点赞数 30
分类专栏： Java并发编程 文章标签： java 开发语言 intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mycode111/article/details/140586065
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

一、线程池

1.1 池化（Pooling）

池化（Pooling）思想是一种常见的软件设计模式，主要目的是在程序运行过程中预先创建和维护一组可重用的资源对象（如线程（Thread）、数据库连接（Connection）等），以便在需要时能够快速获取，而不是每次需要时都动态创建新的对象。这种做法的核心在于，通过重复利用已经创建的对象，可以避免频繁的创建和销毁操作，从而提升系统的性能、资源利用率和响应速度。
在这里插入图片描述

1.2 为什么需要线程池

在Java中，创建一个线程需要执行new Thread()先获得一个线程对象，然后调用start()方法使得线程开始运行。对于在高并发场景下，如果频繁地创建对象，容易出现OOM（Out Of Memory）错误，并且，如果创建的线程数过多，频繁地进行线程上下文切换也会影响到程序性能。

在Java中使用线程池的主要目的是有效地管理和重用线程，从而提高应用程序的性能和资源利用率。具体来说，使用线程池有以下几个重要的原因：
1.减少资源消耗：创建和销毁线程是一项昂贵的操作，涉及到操作系统的资源分配和内存管理。如果频繁地创建和销毁线程，会消耗大量的系统资源，降低系统的性能。
2.提高响应速度：当任务到达时，线程池中的线程可以立即开始执行，而不需要等待新线程的创建。
3.提高系统稳定性：线程池能够限制并发线程的数量，防止系统因为过度并发而崩溃，提高了系统的稳定性。
4.方便管理线程：线程池提供了统一的接口和管理机制，可以方便地对线程进行监控、统计、调优等操作。

二、自定义线程池

我们可以简单地模拟手写一个基础的线程池实现。基本设计如下图所示：
在这里插入图片描述
其中，线程池从任务队列中取出任务Task交给内部维护的线程Thread来处理，扮演的是“消费者”的角色；任务队列用于存放需要被调度执行的任务，扮演的是“消费品”角色；main线程用于产生任务并将任务存放到任务队列中，扮演的是“生产者”的角色。

2.1 任务队列 - TaskBlockingQueue

任务队列是一个阻塞队列，其实现如下所示：

public class TaskBlockingQueue<T> {
    /**
     * 任务队列：存放任务集合
     */
    private Deque<T> queue = new ArrayDeque<>();
    /**
     * 同步线程之间获取资源
     */
    private ReentrantLock lock = new ReentrantLock();
    /**
     * 生产者条件变量 => 满等待：任务队列queue已满，暂停新增任务
     */
    private Condition fullWaitSet = lock.newCondition();
    /**
     * 消费者条件变量 => 空等待：任务队列queue为空，暂停消费任务
     */
    private Condition emptyWaitSet = lock.newCondition();
    /**
     * 队列容量大小
     */
    private int capacity;

    public TaskBlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    /**
     * 阻塞取出任务
     *
     * @return
     */
    public T take() {
        lock.lock();
        try {
            //当前任务资源为空 -> 暂停消费
            while (queue.isEmpty()) {
                //消费者等待
                try {
                    emptyWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //取出任务消费 --> 头部取出
            T task = queue.removeFirst();
            //唤醒满等待线程
            fullWaitSet.signal();
            return task;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 阻塞添加任务
     * @param task
     */
    public void put(T task) {
        lock.lock();
        try {
            //任务队列满 -- 生产者暂停添加任务
            while (queue.size() == this.capacity) {
                try {
                	//无时限等待
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //可以添加任务 -- 尾部添加
            queue.addLast(task);
            //唤醒空等待线程
            emptyWaitSet.signal();
        } finally {
            lock.unlock();
        }
    }

}

2.2 线程池 - MyThreadPool

自定义线程池类实现如下：

public class MyThreadPool {
    /**
     * 任务队列
     */
    private TaskBlockingQueue<Runnable> taskQueue;
    /**
     * 核心线程数
     */
    private int coreSize;
    /**
     * 执行任务的线程集合
     */
    private HashSet<Worker> workers = new HashSet<>();

    /**
     * 工作线程
     */
    class Worker extends Thread {
        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //任务不为空时 -- 执行任务
            while (null != task || (task = taskQueue.take()) != null) {
                try {
                    log.debug("执行任务: {}", task);
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }
            //循环结束-任务执行完毕，移除worker线程
            synchronized (this) {
                log.debug("移除worker: {}", this);
                workers.remove(this);
            }
        }
    }

    public MyThreadPool(int taskQueueSize, int coreSize) {
        this.coreSize = coreSize;
        this.taskQueue = new TaskBlockingQueue<>(taskQueueSize);
    }

    /**
     * 线程池执行任务
     * @param task
     */
    public void execute(Runnable task) {
       synchronized (workers) {
           //直接交给Worker线程执行
           if (workers.size() < coreSize) {
               Worker worker = new Worker(task);
               log.debug("创建Worker: {}, 任务: {}", worker, task);
               workers.add(worker);
               worker.start();
           }
           //加入阻塞队列暂存
           else {
               log.debug("新增等待任务: {}", task);
               taskQueue.put(task);
           }
       }
    }

}

2.3 测试自定义线程池

2.3.1 死等情况

假设自定义线程池的核心线程数为2，任务队列容量为10，编写测试类如下所示：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(10, 2);
        for (int i = 0; i < 5; i++) {
            int j = i;
            pool.execute(() -> {
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

查看执行结果如下：
在这里插入图片描述
分析可知，工作的两个线程分别为Thread-0、Thread-1。初始时，工作线程数小于核心线程数，Thread-0、Thread-1得到创建并开始执行任务fcb0、3e64（用打印结果的最后4位来代指任务），在Thread-0、Thread-1工作期间，新增的任务37bc、a09c、0994暂时没有空闲的线程来执行，需要放入到任务队列中。当Thread-0、Thread-1执行完任务fcb0、3e64后变为空闲状态，然后从任务阻塞队列（按照加入顺序）读取任务37bc、a09c并执行，执行完毕后Thread-0、Thread-1又变回空闲线程，然后Thread-0取出任务0994执行，Thread-1为空闲且保持运行状态。Thread-0执行完任务0994后，同样处于空闲且保持运行状态。

在整个过程中，只创建了2个（核心线程数）个工作线程用于工作和复用，但从最后结果来看，当任务队列为空即工作线程已经没有任务要执行时，却依旧处于运行状态以等待下一个任务，故需要加上一个超时时间设置来避免工作线程死等的情况。

2.3.2 超时时间设置

对任务阻塞队列的take()方法做增加超时时间设置的改造，如下所示：

/**
     * 阻塞取出任务 -- 设置超时时间
     *
     * @return
     */
    public T poll(long timeout, TimeUnit timeUnit) {
        lock.lock();
        try {
            long nanos = timeUnit.toNanos(timeout);
            //当前任务资源为空 -> 暂停消费
            while (queue.isEmpty()) {
                //消费者等待
                try {
                    //超时时间到
                    if (nanos <= 0) {
                        return null;
                    }

                    //剩余时间
                    nanos = emptyWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //取出任务消费 --> 头部取出
            T task = queue.removeFirst();
            //唤醒满等待线程
            fullWaitSet.signal();
            return task;
        } finally {
            lock.unlock();
        }
    }

同样，线程池实现也做一个对应改造：

public class MyThreadPool {
    /**
     * 任务队列
     */
    private TaskBlockingQueue<Runnable> taskQueue;
    /**
     * 核心线程数
     */
    private int coreSize;
    /**
     * 执行任务的线程集合
     */
    private HashSet<Worker> workers = new HashSet<>();
    /**
     * 时间单位
     */
    private TimeUnit timeUnit;
    /**
     * 超时时间
     */
    private long timeout;

    /**
     * 工作线程
     */
    class Worker extends Thread {
        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //任务不为空时 -- 执行任务
            while (null != task || (task = taskQueue.poll(timeout, timeUnit)) != null) {
                try {
                    log.debug("执行任务: {}", task);
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }
            //循环结束，移除worker线程
            synchronized (this) {
                log.debug("移除worker: {}", this);
                workers.remove(this);
            }
        }
    }

    public MyThreadPool(int taskQueueSize, int coreSize, TimeUnit timeUnit, long timeout) {
        this.coreSize = coreSize;
        this.taskQueue = new TaskBlockingQueue<>(taskQueueSize);
        this.timeUnit = timeUnit;
        this.timeout = timeout;
    }

    /**
     * 线程池执行任务
     * @param task
     */
    public void execute(Runnable task) {
       synchronized (workers) {
           //直接交给Worker线程执行
           if (workers.size() < coreSize) {
               Worker worker = new Worker(task);
               log.debug("创建Worker: {}, 任务: {}", worker, task);
               workers.add(worker);
               worker.start();
           }
           //加入阻塞队列暂存
           else {
               log.debug("新增等待任务: {}", task);
               taskQueue.put(task);
           }
       }
    }

}

假设线程池的超时时间设置为2秒，编写测试类如下，

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(10, 2, TimeUnit.SECONDS, 2);
        for (int i = 0; i < 5; i++) {
            int j = i;
            pool.execute(() -> log.debug("===> {} ", j + 1));
        }
    }
}

运行结果如下所示：
在这里插入图片描述
可以看到，超时时间到了以后，工作线程被移除，整个程序运行结束，工作线程不再是无限死等。

2.3.3 任务队列满

现假设需要执行的任务数暴增，从5个变为15个，已知任务队列的大小为10。编写测试类如下：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(10, 2, TimeUnit.SECONDS, 2);
        for (int i = 0; i < 15; i++) {
            int j = i;
            pool.execute(() -> log.debug("===> {} ", j + 1));
        }
    }
}

运行结果如下：
在这里插入图片描述
向任务队列添加任务时都是阻塞式地添加，在任务数量过多的情况下，如果主线程需要执行过多的添加任务操作，那么就会对主线程的性能造成严重影响，所以对于核心工作线程无空闲的且阻塞任务队列又已满的情况，应该让主线程可以选择性地执行一些拒绝策略。

三、 自定义拒绝策略

3.1 带超时添加任务

改造任务阻塞队列的添加任务方法put，新增超时时间判断处理，如下所示：

 /**
     * 阻塞添加任务 -- 新增超时时间设置
     * @param task
     */
    public boolean offer(T task, long timeout, TimeUnit unit) {
        lock.lock();
        try {
            long nanos = unit.toNanos(timeout);
            //任务队列满 -- 生产者暂停添加任务
            while (queue.size() == this.capacity) {
                log.debug("等待加入任务队列: {}", task);
                if (nanos <= 0) {
                    return false;
                }

                try {
                    nanos = fullWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //可以添加任务 -- 尾部添加
            log.debug("加入任务队列: {}", task);
            queue.addLast(task);
            //唤醒空等待线程
            emptyWaitSet.signal();
            return true;
        } finally {
            lock.unlock();
        }
    }

3.2 拒绝方法

为方便灵活设置拒绝策略，可将拒绝策略定义为一个函数式接口，如下所示：

@FunctionalInterface
public interface MyRejectPolicy<T> {

    /**
     * 拒绝策略设置
     * @param taskQueue
     * @param task
     */
    void reject(TaskBlockingQueue<T> taskQueue, T task);
    
}

改造任务阻塞队列，新增拒绝方法如下所示:

/**
     * 尝试向任务队列新增任务
     * @param rejectPolicy
     * @param task
     */
    public void tryPut(MyRejectPolicy<T> rejectPolicy, T task) {
        lock.lock();
        try {
            //队列已满 ==> 执行拒绝策略
            if (queue.size() == capacity) {
	            log.debug("队列已满,执行拒绝策略...");
                rejectPolicy.reject(this, task);
            } else {
                //队列还有空闲
                log.debug("加入任务队列: {}", task);
                queue.addLast(task);
                //唤醒空等待
                emptyWaitSet.signal();
            }
        } finally {
            lock.unlock();
        }
    }

自定义线程池实现类改造如下：

public class MyThreadPool {
    /**
     * 任务队列
     */
    private TaskBlockingQueue<Runnable> taskQueue;
    /**
     * 拒绝策略
     */
    private MyRejectPolicy<Runnable> rejectPolicy;
    /**
     * 核心线程数
     */
    private int coreSize;
    /**
     * 执行任务的线程集合
     */
    private HashSet<Worker> workers = new HashSet<>();
    /**
     * 时间单位
     */
    private TimeUnit timeUnit;
    /**
     * 超时时间
     */
    private long timeout;

    /**
     * 工作线程
     */
    class Worker extends Thread {
        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //任务不为空时 -- 执行任务
            while (null != task || (task = taskQueue.poll(timeout, timeUnit)) != null) {
                try {
                    log.debug("执行任务: {}", task);
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }
            //循环结束，移除worker线程
            synchronized (this) {
                log.debug("移除worker: {}", this);
                workers.remove(this);
            }
        }
    }

    public MyThreadPool(int taskQueueSize, int coreSize, TimeUnit timeUnit, long timeout,
                        MyRejectPolicy<Runnable> rejectPolicy) {
        this.coreSize = coreSize;
        this.taskQueue = new TaskBlockingQueue<>(taskQueueSize);
        this.timeUnit = timeUnit;
        this.timeout = timeout;
        this.rejectPolicy = rejectPolicy;
    }

    /**
     * 线程池执行任务
     * @param task
     */
    public void execute(Runnable task) {
       synchronized (workers) {
           //直接交给Worker线程执行
           if (workers.size() < coreSize) {
               Worker worker = new Worker(task);
               log.debug("创建Worker: {}, 任务: {}", worker, task);
               workers.add(worker);
               worker.start();
           }
           //加入阻塞队列暂存 -- 设置拒绝策略
           else {
               taskQueue.tryPut(rejectPolicy, task);
           }
       }
    }

}

3.3 测试自定义拒绝策略

3.3.1 拒绝策略-死等

当前工核心线程数为2，任务队列容量为2，待处理任务数量为8，测试类如下所示：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(2, 2, TimeUnit.MILLISECONDS, 1000,
                TaskBlockingQueue::put);
        for (int i = 0; i < 8; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                	//假设工作线程耗时特别久
                    TimeUnit.MILLISECONDS.sleep(1000000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下所示：
在这里插入图片描述
在死等的拒绝策略下，当工作线程无空闲且任务队列已满时，新增任务时将会一直等待到任务队列有空闲为止。

3.3.2 有时限等待 - 超时时间之内

现假设任务执行耗时为2s，超时等待时间为2s，拒绝策略为在1s内尝试将新任务加入任务队列，测试类如下所示：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(1, 1, TimeUnit.MILLISECONDS, 2000,
                (queue, task) -> {
                    //在1s内尝试将任务加到任务队列
                    queue.offer(task, 1000, TimeUnit.MILLISECONDS);
                });
        for (int i = 0; i < 4; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                    //工作线程执行耗时为2s
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下：
在这里插入图片描述
执行拒绝策略时，在超时时间1s内尝试将新任务加入任务队列，但是都加入失败，故最后4个任务中只成功执行了两个任务，另外两个任务因加入任务队列失败而执行失败。

3.3.3 有时限等待 - 超时时间之外

现假设任务执行耗时为2s，超时等待时间为2s，拒绝策略为在3s内尝试将新任务加入任务队列，测试类如下所示：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(1, 1, TimeUnit.MILLISECONDS, 2000,
                (queue, task) -> {
                    //在3s内尝试将任务加到任务队列
                    queue.offer(task, 3000, TimeUnit.MILLISECONDS);
                });
        for (int i = 0; i < 4; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                    //工作线程执行耗时为2s
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下所示：
在这里插入图片描述
工作线程执行任务耗时为2s，而执行拒绝策略时，新增任务的超时等待时间为3s，则新任务可正常被加入到任务队列中，故4个任务全部被执行成功。

3.3.4 放弃任务执行

假设当前核心线程数和任务队列数都为1，待执行任务数量为4，测试类代码如下所示：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(1, 1, TimeUnit.MILLISECONDS, 2000,
                (queue, task) -> {
                    log.debug("放弃执行: {}", task);
                });
        for (int i = 0; i < 4; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                    //工作线程执行耗时为2s
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下所示：
在这里插入图片描述
当任务队列满以后，执行拒绝策略时，最后两个任务放弃了执行，故最终只有两个任务可被正常执行。

3.3.5 抛异常

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(1, 1, TimeUnit.MILLISECONDS, 2000,
                (queue, task) -> {
                    throw new RuntimeException("任务执行失败...");
                });
        for (int i = 0; i < 4; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                    //工作线程执行耗时为2s
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下所示：
在这里插入图片描述
执行拒绝策略时，当新任务无法加入到任务队列时，将直接抛出异常。

3.3.6 调用者线程执行

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(1, 1, TimeUnit.MILLISECONDS, 2000,
                (queue, task) -> {
                    task.run();
                });
        for (int i = 0; i < 4; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                    //工作线程执行耗时为2s
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下所示：
在这里插入图片描述
执行拒绝策略时，无法加入到任务队列的任务将交由调用者线程即main线程来执行，所有任务都可以被执行成功，但是负责执行的线程不一样。

Zzzkt
关注
  • 30
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java并发】-- 线程池
十年磨一剑，沉淀……
07-16 294
文章目录1.为什么要使用线程池？2.Executors提供的四种线程池区别以及应用场景:3.线程池有哪几种工作队列？ArrayBlockingQueue - 有界的数组队列 :LinkedBlockingQueue - 可支持有界/无界的队列 :DelayedWorkQueue优先级队列。PriorityBlockingQueue : 优先队列SynchronousQueue : 队列长度为1...
Java并发编程：线程池
rrq_0324的博客
12-04 1092
1. 基础知识 1.1 线程池的特点 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。（线程复用） 提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。（控制最大并发数） 1.2 异步回调 同步和异步通常用来形容一次方法调用。 同步方法调用一旦开始，调用者必须等到方法调用返回后，才能继续后续的行为。 异步方法调用一旦开始，方法调
Java并发编程-线程池底层工作原理
Java硬件工程师的博客
01-29 2288
关于线程池的具体介绍，可以参看ThreadPool线程池，这里主要介绍线程池底层工作原理。 1.线程池的底层工作原理 1.1.线程池的底层工作原理图 线程池的主要处理原理图和流程图如下 1.2.银行办理业务案例 为了便于理解，我们用银行的例子来说明银行网=线程池 corePoolsize=今日当值窗口。今日当值窗口由两个，当银行客人来了之后，先去候客厅等着，现在来了3个即3，4，5都来了，在候客厅等着，此时候客区也满了。突然，6，7，8三个人又来了，由于候客区也满了，此时可以用到maximumPoolS
Java并发编程-线程池
热门推荐
千月落
02-21 1万+
Java 中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。
Java并发编程-ThreadPool线程池
Java硬件工程师的博客
01-29 5112
1.线程池的优势 1.1.引言 与数据库线程池类似，如果没有数据库连接池，那么每次对数据库的连接池都要new来获取连接池。重复的连接和释放操作会消费大量的系统资源，我们可以使用数据库连接池，直接去池中取连接池。 同样，在没有线程池之前，我们也是通过new Thread.start()来获取线程，现在我们也不需要new了，这样就能实现复用，使得我们系统变得更加高效。 1.2.为什么要使用线程池 例子： 10年前单核CPU电脑，假的多线程，像马戏团小丑玩多个球，CPU需要来回切换。 现在是多核电脑，多个线程各
JAVA并发编程实践-线程池-学习笔记
07-22
Java并发编程实践中的线程池是一个关键的概念，它在多线程编程中扮演着至关重要的角色，有效地管理和调度线程资源，以提高系统的性能和效率。线程池通过复用已存在的线程来减少线程的创建和销毁开销，避免了频繁的上...
深入理解高并发编程-Java线程池核心技术
06-01
总结来说，理解Java并发编程中的线程和线程池技术，包括它们的实现方式、生命周期、执行顺序控制、异步计算模型以及线程安全问题，是提高程序性能和可扩展性的关键。通过合理使用线程池，我们可以有效地管理线程，...
深入理解高并发编程-Java线程池核心技术.rar
03-18
深入理解高并发编程-Java线程池核心技术 全面详解Java线程池核心技术
并发容器和线程池，java并发编程3
04-29
`Future`接口提供了获取异步计算结果的能力，它是Java并发编程中重要的API之一。 ##### 3.1 FutureTask `FutureTask`是`Future`接口的一个具体实现，它可以包装一个`Runnable`或`Callable`对象，并允许用户获取...
Java并发编程：线程池的使用 - 平凡希 - 博客园1
08-04
Java并发编程中的线程池是提高系统效率的关键工具，它解决了频繁创建和销毁线程的问题。线程池通过复用已存在的线程来处理任务，从而避免了每次任务执行完毕后销毁线程的开销。在Java中，线程池的核心实现是`java....
【链表在Java中DeBug】
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
08-19 281
时，你实际上是在告诉当前节点 cur：“你的下一个节点应该是这个新创建的节点。，你将 cur 的引用更新为新创建的节点，这样 cur 现在就指向了你刚刚添加到链表末尾的节点。实际上，head 是一个固定的引用，它始终指向链表的第一个节点（即头节点）。当你看到链表似乎“增长”了，这实际上是因为你通过操作 cur（当前节点的引用）在链表的末尾添加了新的节点。所以，当你看到链表“增长”时，你实际上是在通过更新节点之间的链接（即 next 指针）来扩展链表结构。它只是保持了对链表起始节点的引用。
【Spring框架】
m0_71941456的博客
08-18 1025
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 544
【代码】springboot网上商品订单转手系统bootpf
指针详解（四）
Limerence_Aries的博客
08-18 1020
目录1. 字符指针变量2. 数组指针变量3. 数组指针变初始化4. 二维数组传参的本质5. 函数指针变量1）函数指针变量的创建2）函数指针变量的使用3）代码解析6. typedef关键字7. 函数指针数组8. 转移表 代码const char* pstr = "hello bit."; 不是把字符串 hello bit 放到字符指针 pstr 里，而是把字符串hello bit.的首字符的地址放到了pstr中我们通过一道例题加深理解 所以数组指针变量：存放的应该是数组的地址，能够指向数组的指针变
笔记redis
风止的博客
08-22 583
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
如何使用 Java 记录简化 Spring Data 中的数据实体
08-20 529
Java 开发人员一直依赖Spring Data来实现高效的数据访问。但是，随着Java Records的引入，数据实体的管理方式发生了重大变化。在本文中，我们将讨论 Java Records 在 Spring Data 应用程序中的集成。我们将探讨使用 Java 记录创建健壮的数据实体的好处，并提供真实世界的示例来展示它们在 Spring Data 中的潜力。Java 记录的力量：概述J...
Java学习_18_Stream流
最新发布
qq_41136689的博客
08-23 750
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
微服务框架
Founder_Xiao_Xin的博客
08-20 757
在分布式系统中，服务可能失败导致雪崩，Hystrix 是防雪崩利器，具有服务降级、服务熔断、服务隔离、监控等防止雪崩的技术。服务降级：接口调用失败调用本地方法返回空。服务熔断：接口调用失败进入熔断方法返回错误信息。服务隔离：隔离服务之间相互影响。服务监控：记录服务调用的运行指标。在分布式系统中，一个业务因跨越不同数据库或不同微服务而包含多个子事务，要求所有子事务同时成功或失败，这就是分布式事务。例如某电商系统下单操作，需请求订单服务、账户服务、库存服务。
SpringBoot如何做自动配置
Z_DOUBLE_Y的博客
08-18 830
Spring Boot通过注解开启自动配置，对autoconfigured的jar包下的META-INF下的spring包中下的spring.factories文件进行扫描，这个文件中包含了可以进行自动配置的类，当满足@Condition注解指定的条件时，便在依赖的支持下进行实例化，注册到Spring容器中。用注解来对一些常规的配置做默认配置，简化了各种xml配置内容，使项目能够快速运行。
《JAVA并发编程实践-线程池高级选项及任务执行框架注意事项学习笔记》
本文是关于《JAVA并发编程实践-线程池-学习笔记》中配置和调整线程池时使用的高级选项的总结，重点讲述了在任务执行框架的过程中需要注意的危险。其中包括线程复用原理、线程池的实现原理以及线程池的组成等内容。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值