Java线程池浅淡

最新推荐文章于 2023-06-11 16:13:12 发布
最新推荐文章于 2023-06-11 16:13:12 发布
阅读量652 收藏 1
点赞数
分类专栏： 学习总结 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43502533/article/details/123495749
版权

文章目录

线程池的作用

线程池的作用是为了复用线程，便于线程的管理及规范化。

线程池复用原理

每一个 Thread 的类都有一个 start 方法。 当调用 start 启动线程时 Java 虚拟机会调用该类的 run方法。 那么该类的 run()方法中就是调用了Runnable对象的run()方法。我们可以继承重写Thread 类，在其 start 方法中添加不断循环调用传递过来的Runnable对象。这就是线程池的实现原理。循环方法中不断获取 Runnable是用Queue实现的，在获取下一个 Runnable 之前可以是阻塞的。

线程池运行过程

当提交一个新线程时，判断当前运行线程数是否小于核心线程，如果小于则直接创建，否则判断阻塞队列是否满，如果未满则加入阻塞队列，否则判断当前运行线程是否小于最大线程数量，如果小于则创建线程运行，否则调用拒绝策略。
请添加图片描述

Java提供的线程池

四种常用线程池

  1. FixedThreadPool
    使用Executors.newFixedThreadPool(int nThreads)方法可以创建一个固定线程数量的线程池。
    创建一个线程池，该线程池重用固定数量的线程。在任何时候，最多有nThreads个线程将是活动的处理任务。超出则进入阻塞队列等待。
    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads,
                              0L, TimeUnit.MILLISECONDS,
                              new LinkedBlockingQueue<Runnable>(),
                              threadFactory);
}
  2. SingleThreadExecutor
    使用Executors.newSingleThreadExecutor()方法可以创建一个固定线程数量为1的线程池。
    public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
    (new ThreadPoolExecutor(1, 1,
                            0L, TimeUnit.MILLISECONDS,
                            new LinkedBlockingQueue<Runnable>()));
}
  3. CachedThreadPool
    使用Executors.newCachedThreadPool()方法可以创建一个简单的可缓存的线程池。
    创建一个线程池，当有一个新线程提交时,查看是否能复用旧线程,否则创建一个新线程并加入到池中,如果空闲线程在60秒内无活动则移出线程池。
    public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}
  4. ScheduledThreadPoolExecutor
    使用Executors.newSingleThreadScheduledExecutor()方法可以创建一个可定时任务的线程池。
    创建一个线程池,新线程可设置在提交后多久进行触发。
    public class ScheduledThreadPoolExecutor
    extends ThreadPoolExecutor
    implements ScheduledExecutorService {
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }
}
    ScheduledThreadPoolExecutor继承自ThreadPoolExecutor,所以使用super调用父类构造方法创建线程.

四种线程池存在问题：

FixedThreadPool 和 SingleThreadPool :允许的请求队列长度为 Integer.MAX_VALUE ,可能会堆积大量的请求,从而导致 OOM 。

CachedThreadPool 和 ScheduledThreadPool :允许的创建线程数量为 Integer.MAX_VALUE ,可能会创建大量的线程,从而导致 OOM

自定义线程池ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
                          }

构造方法个属性解析

1. corePoolSize：线程池中的核心线程数量,即使他们是空闲状态。allowCoreThreadTimeOut设置为true后,核心线程空闲时也可通过keepAliveTime超时移除。

2. maximumPoolSize：线程池中最大允许的线程数量。

3. keepAliveTime：当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

4. unit：keepAliveTime的时间单位

5. workQuene：任务队列，被提交但尚未被执行的任务。

6. threadFactory：线程工厂，用于创建线程，一般用默认的即可。

7. handler：拒绝策略，当任务太多来不及处理，如何拒绝任务。

BlockingQueue阻塞队列

  1. ArrayBlockingQueue ：由数组结构组成的有界阻塞队列。
  2. LinkedBlockingQueue ：由链表结构组成的有界阻塞队列。
    默认构造方法容量为Integer.MAX_VALUE,不断向队列添加任务就可能会导致内存溢出。
  3. PriorityBlockingQueue ：支持优先级排序的无界阻塞队列。
  4. DelayQueue：使用优先级队列实现的无界阻塞队列。
  5. SynchronousQueue：不存储元素的阻塞队列。
  6. LinkedTransferQueue：由链表结构组成的无界阻塞队列。
  7. LinkedBlockingDeque：由链表结构组成的双向阻塞队列。

ThreadFactory线程工厂

作用是规范某个线程池内容，如线程名。

默认线程工厂如下:

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }

    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

RejectedExecutionHandler拒绝策略

当等待队列无法放入新线程时触发拒绝策略。

  1. AbortPolicy: 直接抛出RejectedExecutionException异常。
  2. DiscardPolicy：什么都不做。
  3. DiscardOldestPolicy：丢弃等待队列中最早的一个线程，并再次执行当前提交线程。
  4. CallerRunsPolicy：直接由调用者线程自己执行这个线程。

线程池源码分析

功能方法

阅读上述线程池分析后，想必你对于内部逻辑有一些好奇，下面就贴一些针对于基础属性进行分析。

// 线程池状态参数： 前3位表示线程池运行状态，后29位表示线程池中线程数量
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 32-3=29 表示使用29表示线程数量
private static final int COUNT_BITS = Integer.SIZE - 3;
// 值为 000 11111111111111111111111111111
private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;

//表示线程池的几种状态
// RUNNING：    111 00000000000000000000000000000
private static final int RUNNING    = -1 << COUNT_BITS;
// SHUTDOWN：   000 00000000000000000000000000000
private static final int SHUTDOWN   =  0 << COUNT_BITS;
// STOP：       001 00000000000000000000000000000
private static final int STOP       =  1 << COUNT_BITS;
// TIDYING：    010 00000000000000000000000000000
private static final int TIDYING    =  2 << COUNT_BITS;
// TERMINATED： 011 00000000000000000000000000000
private static final int TERMINATED =  3 << COUNT_BITS;

// 通过以下3个方法分析出ctl的使用流程

// 该方法返回值为当前线程池状态    c & 111 00000000000000000000000000000
private static int runStateOf(int c)     { return c & ~COUNT_MASK; }
// 该方法返回值为当前线程数量      c & 000 11111111111111111111111111111
private static int workerCountOf(int c)  { return c & COUNT_MASK; }
// 该方法返回值为ctl。将线程池状态和线程数量填入合并为ctl
private static int ctlOf(int rs, int wc) { return rs | wc; }



// 以下3个方法为CAS和普通修改线程池数量
private boolean compareAndIncrementWorkerCount(int expect) {
    return ctl.compareAndSet(expect, expect + 1);
}

private boolean compareAndDecrementWorkerCount(int expect) {
    return ctl.compareAndSet(expect, expect - 1);
}

private void decrementWorkerCount() {
    ctl.addAndGet(-1);
}  

// 控制访问工作线程的集合和其他监控属性
private final ReentrantLock mainLock = new ReentrantLock();

// 包含池中所有工作线程的集合。通过mainLock来保证并发安全
private final HashSet<Worker> workers = new HashSet<>();

private volatile long keepAliveTime;

// 我们先前了解到keepAliveTime属性的含义，如下布尔值为控制核心线程数的消亡，如果为true则核心线程也会根据keepAliveTime值销毁。
private volatile boolean allowCoreThreadTimeOut;

线程池状态描述及流转如下：

  • RUNNING： 接受新的任务，处理等待队列中的任务
  • SHUTDOWN： 不接受新的任务提交，但是会继续处理等待队列中的任务
  • STOP： 不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程
  • TIDYING： 所有的任务都销毁了，workCount 为 0。线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()
  • TERMINATED：terminated() 方法结束后，线程池的状态就会变成这个

RUNNING -> SHUTDOWN : 调用shutdown()方法会从运行态转为中止状态。
(RUNNING or SHUTDOWN) -> STOP : 调用shutdownNow()方法会从运行或中止态转为终止状态。
SHUTDOWN -> TIDYING： 当线程池和阻塞队列为空时变化
STOP -> TIDYING: 当线程池为空时变化
TIDYING -> TERMINATED: 当terminated()方法执行完成

提交任务

上面简单分析了一些重要参数，接下来我们先分析核心提交流程，看是否跟我们上述所说一致，线程池提交任务方法为execute();

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    
    // 1. 获取当前状态，并调用workerCountOf方法获取线程池数量判断是否小于核心线程，如果小于则创建Worder，否则执行下一步骤
    // 2. 判断当前是否是运行状态且入队成功，如果成功，则重复检查下运行状态，如果状态被并发改变时，移除队列中新添加的任务，执行拒绝策略，
    //    如果还在运行状态，则检查是否还有工作线程，检查目的是防止无工作线程且阻塞队列中有任务无线程执行。如果无工作线程则创建临时线程执行。
    // 3. 如果线程池状态不满足或入阻塞队列失败，则创建临时线程执行，如果创建失败则执行拒绝策略。
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    else if (!addWorker(command, false))
        reject(command);
}

addWorder方法分析如下，该方法的返回值为工作线程是否启动，firstTask参数为工作线程启动后第一个执行的任务，如果无任务则为null，默认从阻塞队列中取任务，core参数为该工作线程是否是核心线程，核心线程和非核心线程的区别是默认非核心线程超过空闲时间会被消除，而核心线程不会，具体区别上文已讲述清楚。

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (int c = ctl.get();;) {
        // 检查线程池运行状态，runStateAtLeast方法是比较方法，参数一大于等于参数二
        // 当当前线程池状态大于等于SHUTDOWN时，可以是除了RUNNING的其他4种状态，详情看上文中状态的具体值
        //  这里主要是SHUTDOWN状态和STOP状态区别，STOP不处理任务，SHUTDOWN处理任务。
        if (runStateAtLeast(c, SHUTDOWN)
            && (runStateAtLeast(c, STOP)
                || firstTask != null
                || workQueue.isEmpty()))
            return false;
		// CAS+自旋 自增线程个数，当发生竞争失败或者数量限制返回false
        for (;;) {
            if (workerCountOf(c)
                >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
                return false;
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateAtLeast(c, SHUTDOWN))
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    boolean workerStarted = false;
    boolean workerAdded = false;
    // 该类为线程池内部类，稍后我们进行分析
    Worker w = null;
    try {
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                // 对工作线程数组的修改需要持有mainLock
                int c = ctl.get();

                if (isRunning(c) ||
                    (runStateLessThan(c, STOP) && firstTask == null)) {
                    if (t.isAlive()) // 重复运行
                        throw new IllegalThreadStateException();
                    workers.add(w);
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            // 添加成功后工作线程启动，没成功可能是因为线程池状态不符合或线程已被启动
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
    	// 如果启动失败则从工作队列中移除，工作线程数自减，判断是否需要进入Terminate状态
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

通过以上两个方法源码的深入了解，我们大概了解了线程池的工作流程，就是根据线程池的运行状态和工作线程数进行判断线程池是否需要创建新线程或者接受新任务。

工作线程

接下来我们通过分析内部类Worker来具体了解线程池中工作线程的工作原理。

private final class Worker
     extends AbstractQueuedSynchronizer
     implements Runnable{

     final Thread thread;

     Runnable firstTask;

     volatile long completedTasks;

     Worker(Runnable firstTask) {
		// 调用runWorker方法前禁止中断
         setState(-1); 
         this.firstTask = firstTask;
         this.thread = getThreadFactory().newThread(this);
     }
     
     public void run() {
         runWorker(this);
     }
}

可以看到Worker类继承AQS，实现了一个非公平的不可重入的锁，为了解决工作线程运行中和非运行时的一个状态区分，保证了SHUTDOWN和STOP的区别。并且实现了Runnable接口重写了run方法，runWorker方法则是具体的工作流程方法。

构造方法中通过firstTask属性来保证执行第一个传入的任务，通过thread属性来保证每个线程都是由自定义的ThreadFactory返回的。

接下来我们查看runWorker方法详细分析工作流程

final void runWorker(Worker w) {
	   Thread wt = Thread.currentThread();
	   Runnable task = w.firstTask;
	   w.firstTask = null;
	   w.unlock(); // allow interrupts
	   boolean completedAbruptly = true;
	   try {
	       // 如果task不为空则直接执行 否则从阻塞队列中获取执行
	       while (task != null || (task = getTask()) != null) {
	           w.lock();
	           // 保证中断标志不丢失，重复检测为了避免shutdownNow的竞争
	           if ((runStateAtLeast(ctl.get(), STOP) ||
	                (Thread.interrupted() &&
	                 runStateAtLeast(ctl.get(), STOP))) &&
	               !wt.isInterrupted())
	               wt.interrupt();
	           try {
	               beforeExecute(wt, task);
	               try {
	                   // 提交的Runnable类作为一个普通方法执行
	                   task.run();
	                   afterExecute(task, null);
	               } catch (Throwable ex) {
	                   afterExecute(task, ex);
	                   throw ex;
	               }
	           } finally {
	               task = null;
	               w.completedTasks++;
	               w.unlock();
	           }
	       }
	       completedAbruptly = false;
	   } finally {
	       // 从工作线程集合中移除，并自减线程数（如果是正常退出）
	       // 判断是否需要临时增加非核心线程进行临时处理
	       // 调用tryTerminate方法
	       processWorkerExit(w, completedAbruptly);
	   }
}

我们通过addWorker方法了解到，每次提交一个任务后，任务作为firstTask属性传入，并进行start启动该Worker线程，我们每次提交的任务作为一个普通方法被Worker线程执行。

通过addWorker方法我们可以很方便的理解runWorker方法的执行流程，该方法是写在Worker的run方法中，当线程被启动后执行，正常流程为先获取执行任务（这个任务可以是firstTask属性或者从阻塞队列中取到的任务），获取锁，执行钩子函数，执行任务run方法，执行钩子函数，最后解锁并记录监控数据（当前线程执行多少个任务）。

Worker执行任务前加锁的目的是为了保证shutdown和shutdownNow两种不同中断方式的区别，下文详解。

中断线程

两种方式可以中断线程池，一种是调用shutdown方法，另一种是调用shutdownNow方法。

  • shutdown
public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    // 对于workers集合的修改需要持有锁
    mainLock.lock();
    try {
        // 检查安全性------ 对于主流程无影响
        checkShutdownAccess();
        // 当前状态如果小于SHUTDOWN则CAS加自旋变为SHUTDOWN，即如果当前状态为RUNNING设置为SHUTDOWN
        advanceRunState(SHUTDOWN);
        // 中断线程如果线程未在执行任务
        interruptIdleWorkers();
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
}
  • shutdownNow
public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
		// 设置线程状态为STOP
        advanceRunState(STOP);
		// 中断线程
        interruptWorkers();
		// 阻塞队列中未执行的任务
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}

上述两个函数都表示中断线程池，区别在于中断线程使用的方法不同，并且shutdownNow返回阻塞队列中未执行的线程，而shutdown会将阻塞队列中的任务执行完成。

分析interruptIdleWorkers方法和interruptWorkers方法的不同。

  • interruptIdleWorkers
 private void interruptIdleWorkers() {
     interruptIdleWorkers(false);
 }

private void interruptIdleWorkers(boolean onlyOne) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers) {
            Thread t = w.thread;
            // 遍历每个工作线程，通过tryLock来获取锁，区分空闲线程和正在工作的线程，空闲线程则直接设置中断位，正在工作的线程则通过其他方式来保证
            if (!t.isInterrupted() && w.tryLock()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                } finally {
                    w.unlock();
                }
            }
            if (onlyOne)
                break;
        }
    } finally {
        mainLock.unlock();
    }
}
  • interruptWorkers
private void interruptWorkers() {
    // assert mainLock.isHeldByCurrentThread();
    for (Worker w : workers)
    	// 如果线程启动则直接中断
        w.interruptIfStarted();
}

通过分析interruptIdleWorkers方法和interruptWorkers方法的不同。可以理解SHUTDOWN状态和STOP状态的不同。

SHUTDOWN状态和STOP状态流入TIDYING和TERMINATED是通过tryTerminate方法执行的。

final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        // 如果是RUNNING或TIDYING或TERMINATED状态则直接返回，如果是SHUTDOWN状态且队列不为空直接返回
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateLessThan(c, STOP) && ! workQueue.isEmpty()))
            return;
   		// 判断到这里有两种情况，一种是STOP状态，一种是SHUTDOWN状态且阻塞队列为空
   		// 当工作线程为0时转移状态，否则中断线程。
        if (workerCountOf(c) != 0) { // Eligible to terminate
            interruptIdleWorkers(ONLY_ONE);
            return;
        }

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                try {
                    // 钩子函数
                    terminated();
                } finally {
                    ctl.set(ctlOf(TERMINATED, 0));
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}

该方法的调用时机为两个中断线程池方法，添加工作线程失败，工作线程退出，工作线程集合删除线程时会调用，通过最开始的判断保证不会进行意外的状态变化。

总结

通过上述源码分析我们了解了线程池的工作流程，通过execute提交新任务，线程池根据运行状态启动Worker线程执行提交来的任务，通过shutdown和shutdownNow方法来进行关闭线程池。

聊一下线程池中使用的两个锁
一个是mainLock，用作对于工作线程集合的安全访问和一些其他监控参数（largestPoolSize，completedTaskCount）的安全读取。
另一个是Worker类自己实现的简单不可重入锁，用于区分工作线程执行时机和从阻塞队列获取任务的时机，用于两种停止的不同响应。

聊一下线程池中关于中断的逻辑
无论是线程池中的工作线程中断还是AQS中的获取锁时发生的中断，这些框架仅仅保证中断标志位不会丢失，中断的处理还是交由用户线程去保证，如果用户线程并未保证则相当于无中断。

雨辰465
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【线程池】史上最全的ThreadPoolExecutor源码详解
小七的博客
06-30 2264
史上最全的ThreadPoolExecutor源码详解，一篇文章带你彻底搞懂ThreadPoolExecutor底层原理。
hystrix 源码 线程池隔离_清华毕业扫地僧，带你深入理解线程池与源码阅读，再学不会请打我...
weixin_29886329的博客
12-26 163
前言我们回顾一下上节课的内容：第一个我们讲了一个Executor这个接口，大家回顾一下这个接口是干什么使的，把线程的定义和执行分开，主要来做线程的执行接口。在这它下面有一个整个的这个线程池的生命周期，它里面的方法都给他定义全的接口ExecutorService，他下面还有AbstractExecutor这个没有和大家说，这个无所谓了，是为了哪些个子类做准备的。然后才是各种各样的ThreadPool...
Java 线程池
小默学习笔记
06-06 179
文章目录
高并发编程：线程池
weixin_55229531的博客
06-11 1万+
线程池首先有几个接口先了解第一个是Executor，第二个是ExecutorService，在后面才是线程池的一个使用ThreadPoolExecutor。Executor看它的名字也能理解，执行者，所以他有一个方法叫执行，那么执行的东西是Runnable，所以这个Executor有了之后呢由于它是一个借口，他可以有好多实现，因此我们说，有了Executor之后呢，我们现场就是一个任务的定义，比如Runnable起了一个命令的意思，他的定义和运行就可以分开了，不像我们以前定义一个Thread，new一个Th
Java并发——线程池原理解析
兵临奇点
07-07 371
前言 可以说，线程池是Java并发场景中应用到的最多并发框架了。几乎所有需要异步或者并发执行的任务程序都可以使用线程池。在开发过程中，合理的使用线程池会带来以下3个好处： 降低资源的消耗。如果了解Java线程的前因后果，对于这一点应该很好理解。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。当任务到达时，任务可以不同等到创建线程立即就能立即执行。 提高线程的可管理性。线程是稀缺资源，通过线程池框架可以进行统一的线程分配、监控、调优。 世界上没有完美无瑕的事情，任何事情都有正反两面。
java生成二维码demo
03-07
Java作为一种跨平台的编程语言，提供了多种库来实现二维码的生成，其中ZXing（Zebra Crossing）是一个非常流行的开源项目，专门用于处理一维条形码和二维条形码，包括二维码的生成与解析。 ZXing，即“斑马线”，...
Java语言常规编程特性浅淡.pdf
最新发布
12-27
"Java语言常规编程特性浅淡" 本文将详细介绍Java语言的常规编程特性，从JDK的字符及编程API接口开始，讨论String对象的实例原理及常量池管理方式，然后阐述各种不同类型集合的差别及适用场景，最后分析了线程与进程...
Java基础面试题
11-30
Java 基础面试题详解 在 Java 面试中，了解一些基础知识点是非常重要的。本文将对 Java 基础面试题进行详细的解释，包括 final、finally、finalize 的区别、Anonymous Inner Class、& 和 && 的区别、HashMap 和 ...
java微信小程序开发
03-22
Java微信小程序开发是一种结合了Java编程语言与微信小程序平台的技术实践。微信小程序是腾讯公司推出的一种轻量级应用开发框架，它允许开发者在微信平台上构建无需安装即可使用的应用程序，为用户提供便捷的服务。...
浅淡HTML5移动Web开发
02-26
说实话，我们这次开发移动端的项目，整个项目组的人都是第一次，最初立项的时候为是选择nativeapp和webapp还争论了一番，最后综合考虑，我们选择了web（我们选择了h5）开发。但从这两种开发模式的特点来说，从它们...
黑马程序员—多线程
continuenext的专栏
03-24 635
------- android培训、java培训、期待与您交流！ ---------- 进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。 一个进程中至少有一个线程。 Java VM  启动的时候会有一个进程java.exe. 该进程中至少一个线程负责java程序的执
拆解ThreadPoolExecutor之关闭线程池和钩子函数方法的各个细节
【原】编程界的小学生
05-31 1004
文章目录如果下面的问题你都会的话就别在这浪费时间啦零、初始shutdown和shutdownNow一、shutdown1、全貌2、为什么上锁？3、checkShutdownAccess4、advanceRunState4.1、拆解1:runStateAtLeast4.2、拆解2:compareAndSet4.3、小结5、interruptIdleWorkers5.1、拆解1:参数onlyOne5.2、拆解2:为什么上锁5.3、拆解3:for(Worker w : workers)5.4、拆解4:if判断5.
0.9.3、线程池—— ThreadPoolExecutor 的基础变量 ctl 、 runState 和 workerCount
༺ bestcxx的专栏 ༻
12-12 1083
线程池1、一些基础知识1.1、真值、机器数（原码、反码和补码）1.2、与、或、异或、非运算1.3、位移运算 <<、>>和>>>2、Java 线程池中的一些基础变量ThreadPoolExecutor 1、一些基础知识 1.1、真值、机器数（原码、反码和补码） 真值:就是现实世界的值 机器数:计算机世界中的数字，原码、反码和补码都是机器数的一种 原码:真值变为原码就是，首位表示正负，0为正，1为负，值的部分变为二进制 反码:正数的反码是其本身，负数的反码是除符号位外其
11-线程池原理分析
weixin_45596022的博客
02-19 350
一，线程池的基本使用 1，线程池的介绍 线程复用，控制最大并发数，管理线程。 优点：提高响应速度，避免每次都去创建线程。便于管理，降低资源消耗。 2，常用的线程池 1.Executors.newFixedThreadPool(); 执行长期任务性能好，创建一个线程池，一池有N个固定的线程，有固定的线程数的线程 2.Executors.newSingleThreadExecutor(); 一个任务一个任务的执行，一池一线程 3.Executors.newCachedThreadPool(); 执行很多短期异
线程池源码之runWorker方法解析
qq_40223554的博客
07-30 2万+
一切都在源码中 final void runWorker(Worker w) { // 获取当前线程对象的引用 Thread wt = Thread.currentThread(); // 获取worker的firstTask Runnable task = w.firstTask; // 获取完之后把worker的firstTask置为null 防止下次获取到 w.firstTask = null; // 初始化worker的state = 0, e
ThreadPoolExecutor(五)——线程池关闭相关操作
热门推荐
xxcupid的博客
07-22 3万+
补充了和Thread的interrupt操作相关的知识，回头再来看ThreadPoolExecutor中interrupt，关闭线程池等相关操作。 1.interruptIdleWorkers /** * Interrupts threads that might be waiting for tasks (as * indicated by not being locke
Java线程池ThreadPoolExecutor使用和分析(三) - 终止线程池原理
Trust_FreeDom的专栏
04-12 1322
相关文章目录： Java线程池ThreadPoolExecutor使用和分析(一) Java线程池ThreadPoolExecutor使用和分析(二) - execute()原理 Java线程池ThreadPoolExecutor使用和分析(三) - 终止线程池原理 终止线程池主要有两个方法：shutdown() 和 shutdownNow(...
Java通俗易懂30天 第19天:多线程(下)
程序员小刘
09-16 1178
文章目录 文章目录文章目录第8章 多线程线程的生命周期线程的同步同步代码块处理实现Runnable的线程安全问题同步代码块处理继承Thread类的线程安全问题同步方法处理实现Runnable的线程安全问题同步方法处理继承Thread类的线程安全问题线程安全的单例模式之懒汉式死锁的问题Lock锁方式解决线程安全问题线程的通信sleep()和wait()的异同经典例题：生产者/消费者问题JDK5.0新增线程创建方式创建多线程的方式三：实现Callable接口使用线程池的好处创建多线程的方式四：使用线程池 ..
从一个run方法的经历看线程池
u011803809的博客
08-20 2004
测试代码 public class Test { public static void main(String[] args) { ExecutorService executorService = Executors.newSingleThreadExecutor(); executorService.submit(newTask());
springboot整合mybatis和junit
09-13
在`src/test/java`目录下创建测试类，例如`UserMapperTest.java`： ```java @SpringBootTest @RunWith(SpringRunner.class) public class UserMapperTest { @Autowired private UserMapper userMapper; @Test ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值