java使用LinkedBlockingQueue实现 生产者 消费者模式

LinkedBlockingQueue 链式阻塞队列的使用方法和原理 相关性文章: 了解BlockingQueue 大体框架和实现思路 并发相关文章: ReentrantLock源码 解析AQS锁加锁释放锁的实现机制 CAS算法详解 ABA问题以及解决办法 目录 概览 使用方法 源码解析 说明 队列容器 结构图 next三种情况 入队操作 出队操作 关键成员变量 初始化 put方法 put方法几个关注点 总体分析 count属性并发问题 唤醒消费者 take方法 总结 概览 1. 基于链表的可选有界阻塞队列。根据F.. 阅读详情

Java中使用LinkedBlockingQueue实现生产者,消费者模式


LinkedBlockingQueue实现是线程安全的,实现了FIFO(先进先出)等特性. 是作为生产者消费者的首选,LinkedBlockingQueue 可以指定容量,也可以不指定,不指定的话,默认最大是Integer.MAX_VALUE,其中主要用到put和take方法,put方法在队列满的时候会阻塞直到有队列成员被消费,take方法在队列空的时候会阻塞,直到有队列成员被放进来。


书本上的话不再重复, 还是看看实例代码.


工厂生产制造  生产高大上洒, 还有美女.

消费者有X二代,也有导演.

让消费者抢资源吧.



生产者实现

package cn.hpc.producerConsumer;

import java.util.UUID;
import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {
    private BlockingQueue<String> queue;
    private String produce;
    public Producer(BlockingQueue<String> queue, String produce) {
        this.queue = queue;
        if (null != produce)
        	this.produce = produce;
        else this.produce = "null ";
    }

    @Override
    public void run() {
        String uuid = UUID.randomUUID().toString();
        try {
        	Thread.sleep(200);//生产需要时间
            queue.put(produce + " : " + uuid);
            System.out.println("Produce \"" + produce + "\" : " + uuid + " " + Thread.currentThread());
            
        } catch (InterruptedException e) {
            System.out.println(e.getMessage());
        }
    }
}       

消费者


package cn.hpc.producerConsumer;

import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable {
	private BlockingQueue<String> queue;
	private String consumer;

	public Consumer(BlockingQueue<String> queue, String consumer) {
		this.queue = queue;
		if (null != consumer)
			this.consumer = consumer;
		else
			this.consumer = "null ";
	}

	@Override
	public void run() {
		try {
			String uuid = queue.take();
			System.out.println(consumer + " decayed " + uuid
					+ " " + Thread.currentThread());
		} catch (InterruptedException e) {
			System.out.println(e.getMessage());
		}
	}
}


调用 :  new Tester();

做

package cn.hpc.producerConsumer;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

public class Tester {

    public Tester(){
        // 队列
        LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<String>(10);

        
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 6; i++) {
        	service.submit(new Consumer(queue, "X二代" + i));
        	service.submit(new Consumer(queue, "导演" + i));
        }
        for (int i = 0; i < 6; i++) {
        	service.submit(new Producer(queue, "黄金酒," + i));
        	service.submit(new Producer(queue, "美女演员" + i));
        }
        service.shutdown();
    }
}    



看看输出日志


12-26 12:13:07.689: I/System.out(19372): Produce "黄金酒0" : 67cbb3c8-b72b-4bd5-9edc-f1c3314e9f50 Thread[pool-1-thread-13,5,main]
12-26 12:13:07.699: I/System.out(19372): 导演4 decayed 美女演员4 : 73e6939e-287e-4dda-88ff-2a59871f8a41 Thread[pool-1-thread-10,5,main]
12-26 12:13:07.699: I/System.out(19372): Produce "黄金酒1" : 21f150e3-7909-47c3-a5b1-31b4f4242446 Thread[pool-1-thread-15,5,main]
12-26 12:13:07.699: I/System.out(19372): X二代5 decayed 黄金酒5 : 66d5449b-ad38-41fe-8012-224b0f996697 Thread[pool-1-thread-11,5,main]
12-26 12:13:07.699: I/System.out(19372): Produce "黄金酒5" : 66d5449b-ad38-41fe-8012-224b0f996697 Thread[pool-1-thread-23,5,main]
12-26 12:13:07.699: I/System.out(19372): 导演5 decayed 美女演员5 : d6008dee-c42f-4c09-8856-ae38ac64e104 Thread[pool-1-thread-12,5,main]
12-26 12:13:07.699: I/System.out(19372): Produce "美女演员1" : 9786647d-c499-40be-9905-da767ae2fe88 Thread[pool-1-thread-16,5,main]
12-26 12:13:07.699: I/System.out(19372): Produce "美女演员3" : 72fcbcec-c903-4310-886a-40e31c693248 Thread[pool-1-thread-20,5,main]
12-26 12:13:07.699: I/System.out(19372): X二代2 decayed 黄金酒2 : 75f1952c-975d-41b1-ba69-9e24006031cd Thread[pool-1-thread-5,5,main]
12-26 12:13:07.699: I/System.out(19372): 导演2 decayed 美女演员2 : adb8b376-83c4-487b-9af1-11c16d060ee4 Thread[pool-1-thread-6,5,main]
12-26 12:13:07.699: I/System.out(19372): 导演3 decayed 美女演员3 : 72fcbcec-c903-4310-886a-40e31c693248 Thread[pool-1-thread-8,5,main]
12-26 12:13:07.699: I/System.out(19372): Produce "黄金酒2" : 75f1952c-975d-41b1-ba69-9e24006031cd Thread[pool-1-thread-17,5,main]
12-26 12:13:07.699: I/System.out(19372): Produce "美女演员0" : aad2007e-6322-43bc-a1f3-ade9af671e7b Thread[pool-1-thread-14,5,main]
12-26 12:13:07.699: I/System.out(19372): X二代0 decayed 黄金酒0 : 67cbb3c8-b72b-4bd5-9edc-f1c3314e9f50 Thread[pool-1-thread-1,5,main]
12-26 12:13:07.699: I/System.out(19372): 导演0 decayed 美女演员0 : aad2007e-6322-43bc-a1f3-ade9af671e7b Thread[pool-1-thread-2,5,main]
12-26 12:13:07.699: I/System.out(19372): X二代1 decayed 黄金酒1 : 21f150e3-7909-47c3-a5b1-31b4f4242446 Thread[pool-1-thread-3,5,main]
12-26 12:13:07.699: I/System.out(19372): 导演1 decayed 美女演员1 : 9786647d-c499-40be-9905-da767ae2fe88 Thread[pool-1-thread-4,5,main]
12-26 12:13:07.699: I/System.out(19372): Produce "黄金酒3" : c0ff371e-473d-4af0-90a7-620fa67c22d8 Thread[pool-1-thread-19,5,main]
12-26 12:13:07.699: I/System.out(19372): Produce "美女演员5" : d6008dee-c42f-4c09-8856-ae38ac64e104 Thread[pool-1-thread-24,5,main]
12-26 12:13:07.699: I/System.out(19372): Produce "黄金酒4" : 272cb2a6-b1dd-44d8-8254-df4f6be59bd2 Thread[pool-1-thread-21,5,main]
12-26 12:13:07.699: I/System.out(19372): Produce "美女演员2" : adb8b376-83c4-487b-9af1-11c16d060ee4 Thread[pool-1-thread-18,5,main]
12-26 12:13:07.699: I/System.out(19372): Produce "美女演员4" : 73e6939e-287e-4dda-88ff-2a59871f8a41 Thread[pool-1-thread-22,5,main]
12-26 12:13:07.699: I/System.out(19372): X二代3 decayed 黄金酒3 : c0ff371e-473d-4af0-90a7-620fa67c22d8 Thread[pool-1-thread-7,5,main]
12-26 12:13:07.699: I/System.out(19372): X二代4 decayed 黄金酒4 : 272cb2a6-b1dd-44d8-8254-df4f6be59bd2 Thread[pool-1-thread-9,5,main]



生产者-消费者模式 我们可以在生产者和消费者之间加一个阻塞队列(也可以是用阻塞队列实现的程序,或者是部署了阻塞队列的服务器),让生产者和消费者通过队列来进行通信,消费者把请求发送到队列里,消费者从队列中拿生产者发送的数据,生产者从队列中获取请求,把返回的响应发送到队列里。有的时候生产者生产数据的速度远远大于消费者取数据的速度,那么队列满的时候,生产者就进入阻塞状态,生产不了数据,等消费者取数据的时候才能从阻塞状态解除,继续去生产数据。在队列空的时候,出队列操作对进入阻塞,等队列不空的时候再解除阻塞,继续出队列。 阅读详情

相关推荐

记一次wireshark抓取QQ好友IP和火绒抓取微信IP

事情是这样的,,上个周,手机离奇的被盗,但没有关机,为了找回手机,粗学了一手QQ抓ip的手段。 这里我就直接做个演示,解析关键的点。 三种思路i. wireshark 抓取手机在线IPii 火绒抓取 微信在线接听IPiii 火绒抓取 微信在线不接听IP i. wireshark 抓取手机在线IP wireshark抓好友QQ的ip要求和对方打语音的时候要手机在线。 这里说一下,打语音和视频是直接能和对方建立连接,如果发文件,是直接发给腾讯的,抓不到包。 1.打开wireshark,通过电脑Tim给对方打语音

qq_29437513的博客 1万+

Java并发体系--LinkedBlockingDeque

LinkedBlockingDeque是一个线程安全的双端队列,它是基于链表的数据结构实现的。它继承自AbstractQueue类并实现了BlockingDeque接口。它可以在队列的两端进行元素的插入和删除操作。LinkedBlockingDeque可以选择有限容量或无限容量。如果指定了容量,那么在插入元素时,如果队列已满,插入操作将会阻塞,直到有空间可用。如果没有指定容量,那么队列的容量将是无限的。LinkedBlockingDeque以链表的形式存储元素,这样可以实现高效的插入和删除操作。

Flying_Fish_roe的博客 1367

机械臂开发必备:KDL库正逆解与动力学实战指南

在机器人算法领域,运动学与动力学计算是机械臂控制、仿真与轨迹规划的核心基础。正运动学描述关节空间到笛卡尔空间的映射,逆运动学则需要求解复杂的非线性方程,工程实现时常面临数值稳定性与调试效率的挑战。KDL(Kinematics and Dynamics Library)作为ROS生态中广泛使用的开源库,提供了统一的模型描述与高效求解器,将正逆解、雅可比矩阵及动力学参数计算封装为简洁接口,大幅降低开发门槛。无论是机械臂的笛卡尔空间轨迹跟踪,还是基于动力学模型的前馈控制,KDL都展现出强大的工程价值。本文从运动学

weixin_33860528的博客 2506

设计模式一:生产者消费者模式(及LinkedBlockingQueue的介绍使用)

  在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。一、为什么要使用生产者和消费者模式在线程世界里,生产者就是生产数据的线程,消费者就是消费数据的线程。在多线程开发当中,如果生产者处理速度很快,而消费者处理速度很慢,那么生产者就必须等待消费者处理完,才能继续生产数据。同样的道理,如果消费者的处理能力大于生产者,那...

沧鹫小hai的博客 700

c++11 无锁队列

/************************************************************************* &gt; File Name: lockfreequeue.cpp &gt; Author: &gt; Mail: &gt; Created Time: Wed 08 Aug 2018 11:38:08 AM CST ********...

qq_35728402的博客 5021

Transformer在CV里太耗算力?手把手拆解Restormer的MDTA与GDFN模块

本文深度解析了CVPR2022最佳论文提名作品Restormer的创新模块MDTA与GDFN,有效解决了Transformer在计算机视觉领域的高计算复杂度问题。通过通道注意力降维和门控前馈网络设计,Restormer在图像恢复重建任务中显著降低计算量,同时保持高性能,为实时图像处理提供了可行方案。

weixin_30258901的博客 445

共享队列 java_JAVA多线程之间共享数据BlockingQueue介绍

在JAVA的Concurrent包中,BlockingQueue很好的解决了多线程中,如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类,为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员,包括他们各自的功能以及常见使用场景。一、认识BlockingQueue阻塞队列,顾名思义,首先它是一个队列,而一个队列在数据结构中所起的作用大...

weixin_29663061的博客 1326

Android Camera驱动开发工程师面试指南:技术深度与实战准备

摘要:上海移远通信招聘Android Camera驱动开发工程师,主要负责Camera传感器驱动开发维护、高通/展锐平台底层开发及技术预研。岗位要求1年以上嵌入式开发经验,精通Camera传感器驱动调试,熟悉高通平台Camera架构及Android HAL框架。具备HAL开发、算法集成或车载/支付行业经验者优先。工作内容以Driver/HAL开发为主,需具备硬件接口评估能力。该职位接受Linux/单片机背景人员转型。

郑伟强dev的专栏 280

基于LinkedBlockingQueue实现的简版的消息队列

前言 最近在精简系统的...

法号钦尘的博客 654

HotSpot G1 GC 的分区记账、SATB 并发标记与停顿目标调优解析

线上GC毛刺该调停顿目标、加大新生代还是换收集器?本文从HotSpot G1的设计出发,梳理分区与巨型对象、卡表与记忆集、写屏障与细化线程、停顿预测、SATB并发标记、自适应IHOP、混合回收规则及Full GC兜底,并注明JDK8至JDK27的版本差异。文中在JDK8与JDK17上实测:停顿目标从200ms降到20ms,伊甸区缩小四成、P99下降但仍超目标;巨型对象会反复触发又撤销并发标记;JDK17并行Full GC平均停顿约为JDK8的三成。最后给出日志解读、参数清单、调优流程与选型。

曾经“等你生日那天”都遥远得像未来,如今却可欢愉的挥手说“下个十年见” 170万+

buildozer

/home/chenyang/new_kivy/.buildozer/android/platform/build/build/other_builds/hostpython3/desktop/hostpython3/Lib

东方佑 16万+

java消费者生产者模式及JDK之阻塞队列LinkedBlockingQueue实现

生产者消费者问题    (英语:Producer-consumer problem),也称有限缓冲问题(英语:Bounded-buffer problem),是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程。与此同时,消费者也在缓冲区消耗这

业精于勤,荒于嬉;行成于思,毁于随。 2538

AF自动对焦 CDAF PDAF

前言 主流的AF: CDAF, PDAF, laser assist AF(这个只是辅助,在微距或者拍摄纹理不明显的场景下好用)。 1.cdaf原理 CDAF的大致原理就是检测图像锐度或者等价于锐度的参数,不断推动马达寻找最清晰点实现合焦或者对焦。如下图: 缺点:对焦准确,速度慢,由于camera帧率,cpu处理速度,马达反映时间问题不能实时对焦运动物体。 2.pdaf原理 计算相位差,将相位差转换为相位差和af code的关系....

camerall 1万+

LinkedBlockingQueue 实现 生产者 消费者

Java中使用LinkedBlockingQueue实现生产者,消费者模式LinkedBlockingQueue实现是线程安全的,实现了FIFO(先进先出)等特性. 是作为生产者消费者的首选,LinkedBlockingQueue 可以指定容量,也可以不指定,不指定的话,默认最大是Integer.MAX_VALUE,其中主要用到put和take方法,put方法在队列满的时候会阻塞直到有队列成员被消...

大树叶 技术专栏 3106

深度学习工具包 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")

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

ArrayBlockingQueue和LinkedBlockingQueue的使用

ArrayBlockingQueue和LinkedBlockingQueue的使用 博客分类: java.util.concurrent BlockingQueue接口定义了一种阻塞的FIFO queue,每一个BlockingQueue都有一个容量,让容量满时往BlockingQueue中添加数据时会造成阻塞,当容量为空时取元素操作会阻塞。 ...

ane3232的博客 630

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

java 多线程的生产者-消费者 实现

Java 语言实现生产者 --  消费者模式,本文采用1个生产者和3个消费者,以体现多线程并发过程中应该注意的地方。       其中,容器采用java.util.concurrent.LinkedBlockingQueue,这是一个并发容器,包concurrent就是Java专门为实现并发而提供的一组工具包。         思路:一个容量为100的容器,一个生产者(一个线程)

味小道的专栏 843

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

使用Java的BlockingQueue实现生产者-消费者

BlockingQueue也是java.util.concurrent下的主要用来控制线程同步的工具。 BlockingQueue有四个具体的实现类,根据不同需求,选择不同的实现类1、ArrayBlockingQueue:一个由数组支持的有界阻塞队列,规定大小的BlockingQueue,其构造函数必须带一个int参数来指明其大小.其所含的对象是以FIFO(先入先出)顺序排序的。 2、Li...

飘零的云 656

使用LinkedBlockingQueue来实现生产者消费者的例子

工作中,经常有将文件中的数据导入数据库的表中,或者将数据库表中的记录保存到文件中。为了提高程序的处理速度,可以设置读线程和写线程,这些线程通过消息队列进行数据交互。本例就是使用了LinkedBlockingQueue来模仿生产者线程和消费者线程进行数据生产和消费。 为了方便,这些不同的类被写在了一个类中,实际使用的时候,可以单独拆开,举一反三地使用。 以下是例子: LinkedBlockingQ...

hawanglc的博客 1475

21.使用LinkedBlockingQueue模拟生产者与消费者

import java.util.concurrent.BlockingQueue; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; /** * 生产者 */ public class ProducerThread implements Runnable...

216

Java实现生产者与消费者模式

  生产者不断向队列中添加数据,消费者不断从队列中获取数据。如果队列满了,则生产者不能添加数据;如果队列为空,则消费者不能获取数据。借助实现了BlockingQueue接口的LinkedBlockingQueue来模拟同步。 1 import java.util.Random; 2 import java.util.concurrent.BlockingQueue; 3 ...

aotangai1607的博客 269

阻塞队列 LinkedBlockingQueue

1 api java.util.concurrent包下的新类。LinkedBlockingQueue就是其中之一,是一个阻塞的线程安全的队列,底层采用链表实现。 LinkedBlockingQueue构造的时候若没有指定大小,则默认大小为Integer.MAX_VALUE,当然也可以在构造函数的参数中指定大小。LinkedBlockingQueue不接受nu...

潜行IT的博客 250

LinkedBlockingQueue实现生产者-消费者模式

由于LinkedBlockingQueue 实现是线程安全的,实现了先进先出等特性,是作为生产者消费者的首选,LinkedBlockingQueue 可以指定容量,也可以不指定,不指定的话,默认最大是Integer.MAX_VALUE,其中主要用到put和take方法,put方法在队列满的时候会阻塞直到有队列成员被消费,take方法在队列空的时候会阻塞,直到有队列成员被放进来。   Ja

mingyunduoshou的专栏 2023

利用LinkedBlockingQueue实现生产者-消费者模式

由于LinkedBlockingQueue 实现是线程安全的,实现了先进先出等特性,是作为生产者消费者的首选,LinkedBlockingQueue 可以指定容量,也可以不指定,不指定的话,默认最大是Integer.MAX_VALUE,其中主要用到put和take方法,put方法在队列满的时候会阻塞直到有队列成员被消费,take方法在队列空的时候会阻塞,直到有队列成员被放进来。下面是一个例子,一看

Shawn 752

用阻塞队列LinkedBlockingQueue实现生产者消费者先进先出

在Java多线程应用中,队列的使用率很高,多数生产消费模型的首选数据结构就是队列(先进先出)。Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列,其中阻塞队列的典型例子是BlockingQueue,非阻塞队列的典型例子是ConcurrentLinkedQueue,在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。 注:什么叫线程安全?这个首先要明确。线程安全就是说多线程访问同一代码,不会产生不确定的结果。 并行和并发区别 1、并行是指两者同时执行一件事,比如赛跑,两个人都在不停的往前跑; 2

done58的专栏 9919
上一篇: Android Intent 序列化反序列化
下一篇: 再谈 android 设备SN的获取 续 android 设备唯一码的获取,Cpu号,Mac地址
hpccn
博客等级 码龄19年 56粉丝 56原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值