线程池(一)

聊一聊线程池 它最大的作用就是对线程池中的线程进行某种程度的定制,比如线程的优先级,线程的名称。不过以上规则都是纸面上的,我们大多数实际的工作任务都是CPU和IO的混合型任务,很难直接根据经验给出合适的值,最佳的方式是对线程池的使用进行持续的监控,根据监控结果来动态的调整线程池的各项参数。另外线程池的使用还可以增加对线程的可管理性,因为线程池除了复用线程外,还有个重要的作用就是限制对线程的创建,对于线程这种重量级的资源,如果任由应用进行创建而没有抑制的手段,本身就是很危险的。,我们这里不谈具体用法,主要聊一些核心概念。 阅读详情

1、初始化线程池的4种方式

​ 1 继承 Thread类

​ 2 实现 Runnable 接口,并重写run方法

​ 3 实现 Callable 接口 + FutureTask (可以拿到返回结果,可以处理异常)

​ 4 线程池

区别:1、2不能得到返回值,3可以获取返回值

​ 1、2、3都不能控制资源

​ 4可以控制资源,性能稳定

@Slf4j
public class ThreadTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        log.info("mian start............");
        /**
         * 1)、继承 Thread
         * 2)、实现 Runnable 接口
         * 3)、实现 Callable 接口 + FutureTask (可以拿到返回结果,可以处理异常)
         * 4)、线程池
         */

        // 1.继承 Thread
        log.info("mian start............");
        Thread01 thread01 = new Thread01();
        thread01.start(); // 启动线程
        log.info("mian end............");

        // 2、实现runnable接口
        /*
        Runnable01 runnable01 = new Runnable01();
        new Thread(runnable01).start();
        */

        // 3、实现 Callable 接口 + FutureTask
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable01());
        new Thread(futureTask).start();
        //  阻塞等待整个线程执行完,获取返回结果
        Integer integer = futureTask.get();
        log.info("mian end............" + integer);
        

        // 线程池   给线程池直接提交任务
        /**
         * 以上三种方式启动线程的方式缺点是比较吃cpu资源
         * 【将所有的多线程异步任务都交给线程池执行】
         */
    }

    public static class Thread01 extends Thread{
        @Override
        public void run() {
            log.info("当前线程:" + Thread.currentThread().getId());
            int i = 10/2;
            log.info("运行结果:{}",i);
        }
    }

    public static class Runnable01 implements Runnable{

        @Override
        public void run() {
            log.info("当前线程:" + Thread.currentThread().getId());
            int i = 10/2;
            log.info("运行结果:{}",i);
        }
    }

    public static class Callable01 implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            log.info("当前线程:" + Thread.currentThread().getId());
            int i = 10/2;
            log.info("运行结果:{}",i);
            return i;
        }
    }
}

2、线程池

2.1 线程池架构

在这里插入图片描述
上图是线程池的架构图,Java里面线程池的顶级接口是Executor,Executor并不是一个线程池,而只是一个执行线程的工具。真正的线程池接口是ExecutorService。
比较重要的几个类:
在这里插入图片描述
要配置一个线程池时比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,很可能配置的线程池不是很合理的,因此在Executors类里面提供了一些静态工厂,生成一些常用的线程池。
Java通过Executor工厂类提供四种线程池,分别为:
1、newCachedThreadPool :创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,否则新建线程。(线程最大并发数不可控制)

2、newFixedThreadPool:创建一个固定大小的线程池,可控制线程最大并发数,超出的线程会在队列中等待。

3、newScheduledThreadPool : 创建一个定时线程池,支持定时及周期性任务执行。

4、newSingleThreadExecutor :创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

2.2 线程池的创建

​ 1)new ThreadPoolExecutor()

		/**
			七大参数
         *     int corePoolSize:核心线程数【一直存在】,线程池,创建好以后就准备就绪的线程数量,就等待来接收异步任务去执行
         *     int maximumPoolSize:最大线程数,作用:控制资源
         *     long keepAliveTime:存活时间,如果当前的线程数量大于核心数量。释放空闲的线程(超出核心线程的线程部分,核心线程是不释放的),只要线程空闲大于指定的keepAliveTime
         *     TimeUnit unit:时间单位
         *     BlockingQueue<Runnable> workQueue:阻塞队列,如果任务有很多,就会将目前多的任务放在队列里面
         *                                        只要有线程空闲,就会去队列里面取出新的任务继续执行
         *     ThreadFactory threadFactory:线程的创建工厂,一般默认使用:Executors.defaultThreadFactory()
         *     RejectedExecutionHandler handler:如果队列满啦,按照我们指定的拒绝策略执行任务
**/
ThreadPoolExecutor executor = new ThreadPoolExecutor(
                5,
                200,
                10,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(100000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
  1. 使用Executors直接创建的线程池
1) Executors.newCachedThreadPool(); core是0,所有都可回收
2) Executors.newFixedThreadPool(10); 固定大小,core=max,都不可回收
3) Executors.newScheduledThreadPool(10); 定时任务的线程池
4) Executors.newSingleThreadExecutor(); 单线程的线程池,后台从队列里面获取任务,一个一个执行
2.3 线程池的工作流程

​ 流程图:
在这里插入图片描述

流程步骤:

​ 1、线程池创建,准备好核心线程,准备接收任务

​ 2、任务存放顺序,先是判断核心数,如果小于核心数就存入核心线程池中

​ 3、如果大于核心数,就会将进来的任务放入阻塞队列中,空闲的核心线程就会去阻塞队列中获取任务执行

​ 4、当阻塞队列已满,就直接开新的线程执行,最大只能开到max指定的数量

​ 5、max都执行完成,有很多空闲的线程,在指定的存活时间keepAliveTime以后,就会释放(max-core)这一部分的线程,核心线程不会释放

​ new LinkedBlockingDeque<>(100000): 默认是Integer的最大值,内存不足,需要在创建的时候指定大小

2.4 经典面试题
一个线程池 core 7; max 20 ,queue:50,100 并发进来怎么分配的;
* 先有 7 个能直接得到执行,接下来 50 个进入队列排队,在多开 13 个继续执行。现在 70 个
* 被安排上了。剩下 30 个默认拒绝策略。
2.5 使用线程池的好处

1) 降低资源的消耗

  • 通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗

2)提高响应速度

  • 因为线程池中的线程数没有超过线程池的最大上限时,有的线程处于等待分配任务的状态,当任务来时无需创建新的线程就能执行

3)提高线程的可管理性

  • 线程池会根据当前系统特点对池内的线程进行优化处理,减少创建和销毁线程带来的系统开销。无限的创建和销毁线程不仅消耗系统资源,还降低系统的稳定性,使用线程池进行统一分配
2.6 详解各个参数

1)maximumPoolSize

​ 线程池中的最大线程数。表示线程池中最多可以创建多少个线程,很多人以为它的作用是这样的:”当线程池中的任务数超过 corePoolSize 后,线程池会继续创建线程,直到线程池中的线程数小于maximumPoolSize“,其实这种理解是完全错误的。它真正的作用是:当线程池中的线程数等于 corePoolSize 并且 workQueue 已满,这时就要看当前线程数是否大于 maximumPoolSize,如果小于maximumPoolSize 定义的值,则会继续创建线程去执行任务, 否则将会调用去相应的任务拒绝策略来拒绝这个任务。另外超过 corePoolSize的线程被称做"Idle Thread", 这部分线程会有一个最大空闲存活时间(keepAliveTime),如果超过这个空闲存活时间还没有任务被分配,则会将这部分线程进行回收。

2)workQueue

阻塞队列。如果当前线程池中的线程数目>=corePoolSize,则每来一个任务,会尝试将其添加到该队列当中,注意只要超过了 corePoolSize 就会把任务添加到该缓存队列,添加可能成功也可能不成功,如果成功的话就会等待空闲线程去执行该任务,若添加失败(一般是队列已满),就会根据当前线程池的状态决定如何处理该任务(若线程数 < maximumPoolSize 则新建线程;若线程数 >= maximumPoolSize,则会根据拒绝策略做具体处理)。

常用的阻塞队列有:

1)ArrayBlockingQueue       // 基于数组的先进先出队列,此队列创建时必须指定大小;

2)LinkedBlockingQueue      // 基于链表的先进先出队列,如果创建时没有指定此队列大小,则默认为Integer.MAX_VALUE;

3)synchronousQueue       // 这个队列比较特殊,它不会保存提交的任务,而是将直接新建一个线程来执行新来的任务。

3)threadFactory(线程工厂)

线程工厂。用来为线程池创建线程,当我们不指定线程工厂时,线程池内部会调用Executors.defaultThreadFactory()创建默认的线程工厂,其后续创建的线程优先级都是Thread.NORM_PRIORITY。如果我们指定线程工厂,我们可以对产生的线程进行一定的操作。

4)handler(拒绝执行策略)

拒绝执行策略。当线程池的缓存队列已满并且线程池中的线程数目达到maximumPoolSize,如果还有任务到来就会采取任务拒绝策略,通常有以下四种策略:

  • 丢弃任务并抛出RejectedExecutionException异常:ThreadPoolExecutor.AbortPolicy;

  • 丢弃任务,但是不抛出异常:ThreadPoolExecutor.DiscardPolicy;

  • 丢弃队列最前面的任务,然后重新尝试执行任务(重复此过程):ThreadPoolExecutor.DiscardOldestPolicy;

  • 由调用线程处理该任务:ThreadPoolExecutor.CallerRunsPolicy

Java 的线程工厂 ThreadFactory原理及源码详解 在JDK的源码使用工厂模式,ThreadFactory就是其中一种。 在我们一般的使用中,创建一个线程,通常有两种方式: 继承Thread类,覆盖run方法,实现我们需要的业务 继承Runnable接口,实现run方法,实现我们需要的业务,并且调用new Thread(Runnable)方法,将其包装为一个线程执行 设想这样一种场景,我们需要一个线程池,并且对于线程池中的线程对象,赋予统一的线程优先级、统一的名称、甚至进行统一的业务处理或和业务方面的初始化工作,这时工厂方法就是最好用的方法了 ThreadFactory接口 ThreadFactory接口很简单,源码如下: public int 立即下载

相关推荐

保姆级教程:手把手教你从NASA Earthdata免费下载ASTER L2地表温度数据(附shp文件拖拽技巧)

本文提供了一份详细的ASTER L2地表温度数据下载指南,涵盖从NASA Earthdata注册、数据定位到shp文件拖拽技巧的全流程。特别针对新手常见问题如邮箱选择、密码设置、云量筛选等给出实用解决方案,帮助用户高效获取遥感数据并避免常见陷阱。

weixin_42662605的博客 426

异步与线程池

解决问题:业务处理慢 比如:查询数据,处理请求 一、线程 1、初始化线程的4种方式 1)、继承Thread public static class Thread01 extends Thread{ @Override public void run() { System.out.println("当前线程:"+Thread.currentThread().getId()); int i=10/2;

CB_Beginner的博客 540

1panel面板实战:Docker容器存储路径迁移与优化指南

本文详细介绍了在1panel面板中迁移Docker容器存储路径的完整流程与优化方法。针对系统盘空间不足的常见问题,通过停服务、搬数据、改配置三个核心步骤,指导用户安全地将Docker数据目录迁移至更大容量的独立分区,并提供了迁移后的深度管理技巧与常见避坑指南,帮助用户优化服务器存储资源。

ol789012的博客 868

阻塞队列 — LinkedBlockingDeque源码分析

LinkedBlockingDeque 一个由于链表结构组成的双向阻塞队列,队列头部和尾部都可以添加和移除元素,多线程并发时,可以将锁的竞争对多降到一半。

org_hjh的博客 453

深入博通PEX89000内部:那颗ARM CPU和Synthetic Mode到底能玩出什么花样?

本文深入解析博通PEX89000系列PCIe交换芯片内置的ARM CPU与Synthetic Mode技术,揭示其在AI计算和数据中心的智能潜能。通过ARM Cortex CPU的实时控制和Synthetic Mode的自治网络功能,PEX89000实现了GPU集群的动态拓扑重组和资源池化,大幅提升AI训练效率。文章还探讨了该技术在软件定义数据平面和弹性AI架构中的创新应用。

weixin_30776273的博客 217

macOS安装Cplex+yalmip

macOS安装Cplex+yalmip

DS 4250

Java线程池实验:ArrayBlockingQueue和LinkedBlockingQueue吞吐量测试

二者区别 ArrayBlockingQueue内部使用1个锁来控制队列项的插入、取出操作,而LinkedBlockingQueue则是使用了2个锁来控制,一个名为putLock,另一个是takeLock,但是锁的本质都是ReentrantLock。 Array里面使用的时一个锁,不管put还是take行为,都可能被这个锁卡住,而Linked里面put和take是两个锁,put只会被put行为卡住,而不会被take卡住,这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据,因此吞吐性能自然强

trigger的博客 1282

笔记:使用Materials Studio计算聚合物的玻璃化转变温度

使用Materials Studio计算聚合物的玻璃化转变温度。

FXJgogogo的博客 1943

Java阻塞队列 LinkedBlockingDeque

LinkedBlockingDeque LinkedBlockingDeque类实现了BlockingDeque接口。阅读BlockingDeque文本以获取有关的更多信息。 Deque来自“双端队列” 这个词。Deque是一个队列,你可以在插入和删除队列两端的元素。 LinkedBlockingDeque是一个Deque,如果一个线程试图从中获取一个元素,而队列空的,不管线程从哪一端试图获取元素,都会被阻塞。 以下是实例化和使用LinkedBlockingDeque的例子: BlockingDeque&l

赵彦军 1284

9.23华为OD机试真题 新系统 - 小菊的寻宝之旅 (Java/Py/C/C++/Js/Go)

9.23华为OD机试真题 新系统 - 小菊的寻宝之旅 (Java/Py/C/C++/Js/Go)

算法大师! 1021

tar解压报错 gzip: stdin: unexpected end of file tar: Unexpected EOF in archive

错误现象: [root@centos7-xinsz08 ~]# tar xf prometheus-2.7.2.linux-amd64.tar.gz gzip: stdin: unexpected end of file tar: 归档文件中异常的 EOF tar: 归档文件中异常的 EOF tar: Error is not recoverable: exiting now 错误原因排查 ...

互联网老辛 2万+

Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque

Java 中的 Deque(双端队列)是一种具有队列和栈特性的数据结构,它允许在两端进行插入和删除操作。Deque 接口是 Java 集合框架中的一部分,它定义了双端队列的基本操作。 BlockingDeque 接口: BlockingDeque 接口是 Deque 接口的子接口,它表示一个支持阻塞操作的双端队列。它定义了一些阻塞方法,如 putFirst(), putLast(), takeFirst(), takeLast() 等,这些方法在队列满或空时会阻塞线程。

好看的皮囊千篇一律,有趣的灵魂万里挑一。 4056

STM32入门教程:智能储物柜控制

在这个例子中,我们将使用一个4x4的储物柜,共有16个储物格。我们了解了硬件准备、储物柜电路设计、STM32的基本配置、储物柜控制代码的编写以及测试和调试等方面的知识。根据我们的电路设计,我们需要将一些引脚配置为输出,并将其他引脚配置为输入。在本教程中,我们将使用STM32微控制器来实现一个基本的智能储物柜控制系统。在主函数中,我们将不断循环读取传感器数据,并根据数据的变化来控制储物柜的开关和显示相关信息。这个函数将读取人体感应传感器、温湿度传感器和光照传感器的数据,并将数据存储到相应的变量中。

m0_75244442的博客 663

一张图理解线程池

YQAG 294

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Java线程池 ThreadPoolExecutor(一)线程池的核心方法以及原理

一、概述 在java中创建线程的方式肯定大家都知道,但是这样创建有什么问题呢?当然是有问题的要知道线程在创建时是极其耗费资源的,就比如你要乘坐公交汽车肯定是你也可以用别人也可以用的,不会是你用完或者别人用完就把车子送到废品回收站了,当然是回到公交车站,这个公交车站就好比线程池,公交车就好比一个个线程。不知道大家对这么描述是否理解,不理解也没关系下面有更详细的介绍。 二、初识ThreadPool...

m0_37506254的博客 2万+

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

一、线程池

线程池

小刺猬 1156

线程池(一)线程池的基本使用

一、线程池简介 线程池的概念 线程池就是首先创建一些线相衬,它们的集合称为线程池,使用线程池可以很好的提高性能,线程池在系统启动时既创建大量空闲的线程,程序将一个任务传给线程池。线程池就会启动一条线程来执行这个任务,执行结束后,该线程并不会死亡,而是再次返回线程池中成为空闲状态,等待执行下一个任务。 线程池的工作机制 在线程池的编程模式下,任务是提交给整个线程池,而不是直接提交给某个线程,线程池在拿到任务后,就在内部寻找是否有空闲的线程,如果有,则将任务交给某个空闲的线程 一个线程同时只能执行一个任

清茶与浊酒 6944

线程池总结一

为什么要线程池 java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池 多线程技术主要解决处理器单元内多个线程执行的问题,它可以显著减少处理器单元的闲置时间,增加处理器单元的吞吐能力。 多线程的情况下确实可以最大限度发挥多核处理器的计算能力。但是如果随意使用线程,对系统的性能反而有不利影响。 在简单应用里面看起来没有问题,如果创建了一个线程,并且在run()方法结束后自动回收该线程。但是如果在真实系统里面

qq_52840805的博客 242

一看就明的Java的线程池

参考文档:Java的线程池

A232222的博客 231

一看就懂的JAVA线程池

package com.nipeixing.demo.thread; import java.util.List; import java.util.concurrent.*; /** 线程池API ->接口定义和实现类: 【接口】:Executor : 最上层的接口,定义了执行任务的方法execute 【接口】:ExecutorService : 继承了Executor接口,拓...

qq_40094875的博客 171

线程池一

线程池 Executors的创建线程池的方法,创建出来的线程池都实现了ExecutorService接口。 Java提供的4种线程池:CachedThreadPool、FixedThreadPool、 SingleThreadExecutor、ScheduledThreadPool CachedThreadPool:创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用...

qq_45744182的博客 188

线程池(一)

线程池(一)

19.2.04.157N的博客 1352

深入剖析线程池一

线程池是什么 ​ 刚开始的时候,没有线程池的概念,单线程慢慢满足不了我们的系统开发需求,我们就想多线程开发,但是新来一个任务就创建一个线程,这样肯定不行的,因为线程的创建需要有一定的资源,所以造一个东西能够线程复用,这就是线程池 线程池解决了什么问题 线程复用,降低创建资源的消耗 提高响应速度,来一个任务不用等待线程池的创建,直接从池子里面去拿 线程达到可管理,线程池封装了很多函数可以获取到活跃线程数,阻塞队列任务数等待,可以对线程池进行分配和调控以及可视化 线程池的基本概念 状态 Running

Eric_飞 184

JAVA中的线程池说明一

线程池是一种管理线程的机制,它预先创建一定数量的线程,并将它们放入一个池中。当需要执行任务时,线程池会从池中选择一个空闲的线程来执行任务,而不是每次都创建新的线程。一旦任务完成,线程会被归还到线程池中,等待下一次使用。在之前我们也了解过,相关的池化技术,字符串常量池,数据库连接池,HTTP连接池等,池化技术的思想主要是为了减少每次获取资源的消耗,提高对资源的利用率。线程池的主要优点包括:提高性能,降低资源消耗。

m0_62055442的博客 2095

学习线程池一

1.线程池状态 // 接收新任务,处理阻塞队列中任务 private static final int RUNNING = -1 << COUNT_BITS; // 拒绝新任务,但是会处理阻塞队列中任务 private static final int SHUTDOWN = 0 << COUNT_BITS; // 拒绝...

itQiuLiJun的博客 244
上一篇: ThreadLocal类
下一篇: 异步编排-CompletableFuture
程序员老石
博客等级 码龄8年 286粉丝 162原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值