linux多线程同步之消息队列有何特点?l？

一、linux多线程同步之消息队列有何特点?l？

区别和联系：

1、进程是独立运行的实体，有独立的资源分配；

2、同一进程的线程之间共享进程的资源；

3、所有的进程至少有一个执行线程；

4、线程的创建和切换代价比进程的小；线程间的通信方法：1、同一进程的线程之间通信的最简单办法就是使用全局变量；2、不同进程的线程之间通信需要通过下面进程间的通信来实现；进程间的通信方法：1、管道2、信号量3、共享内存4、消息队列5、套接字

二、linux内核中，工作队列和线程有什么区别？

work queue是一种bottom half，中断处理的后半程，强调的是动态的概念，即work是重点，而queue是其次。

wait queue是一种「任务队列」，可以把一些进程放在上面睡眠等待某个事件，强调静态多一些，重点在queue上，即它就是一个queue，这个queue如何调度，什么时候调度并不重要 等待队列在内核中有很多用途，尤其适合用于中断处理，进程同步及定时。这里只说，进程经常必须等待某些事件的发生。例如，等待一个磁盘操作的终止，等待释放系统资源，或者等待时间经过固定的间隔。等待队列实现了在事件上的条件等待，希望等待特定事件的进程把放进合适的等待队列，并放弃控制权。因此。等待队列表示一组睡眠的进程，当某一条件为真时，由内核唤醒进程。等待队列由循环链表实现，其元素包括指向进程描述符的指针。每个等待队列都有一个等待队列头，等待队列头是一个类型为wait_queue_head_t的数据结构。等待队列链表的每个元素代表一个睡眠进程，该进程等待某一事件的发生，描述符地址存放在task字段中。然而，要唤醒等待队列中所有的进程有时并不方便。例如，如果两个或多个进程在等待互斥访问某一个要释放的资源，仅唤醒等待队列中一个才有意义。这个进程占有资源，而其他进程继续睡眠可以用DECLARE_WAIT_QUEUE_HEAD(name)宏定义一个新的等待队列，该宏静态地声明和初始化名为name的等待队列头变量。init_waitqueue_head()函数用于初始化已动态分配的wait queue head变量等待队列可以通过DECLARE_WAITQUEUE()静态创建，也可以用init_waitqueue_head()动态创建。进程放入等待队列并设置成不可执行状态。工作队列，workqueue，它允许内核代码来请求在将来某个时间调用一个函数。用来处理不是很紧急事件的回调方式处理方法.工作队列的作用就是把工作推后,交由一个内核线程去执行，更直接的说就是写了一个函数,而现在不想马上执行它，需要在将来某个时刻去执行，那就得用工作队列准没错。如果需要用一个可以重新调度的实体来执行下半部处理，也应该使用工作队列。是唯一能在进程上下文运行的下半部实现的机制。这意味着在需要获得大量的内存时、在需要获取信号量时，在需要执行阻塞式的I/O操作时，都会非常有用。

三、线程池队列大小设置？

一、ThreadPoolExecutor的重要参数

corePoolSize：核心线程数， 核心线程会一直存活，及时没有任务需要执行，当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理，设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭

queueCapacity：任务队列容量（阻塞队列）

当核心线程数达到最大时，新任务会放在队列中排队等待执行

maxPoolSize：最大线程数

当线程数>=corePoolSize，且任务队列已满时。线程池会创建新线程来处理任务

当线程数=maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常

keepAliveTime：线程空闲时间

当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量=corePoolSize

如果allowCoreThreadTimeout=true，则会直到线程数量=0

allowCoreThreadTimeout：允许核心线程超时

rejectedExecutionHandler：任务拒绝处理器

两种情况会拒绝处理任务：

当线程数已经达到maxPoolSize，切队列已满，会拒绝新任务

当线程池被调用shutdown()后，会等待线程池里的任务执行完毕，再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务，会拒绝新任务

线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置默认是 AbortPolicy，会抛出异常

ThreadPoolExecutor类有几个内部实现类来处理这类情况：

AbortPolicy 丢弃任务，抛运行时异常

CallerRunsPolicy 执行任务

DiscardPolicy 忽视，什么都不会发生

DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务

实现RejectedExecutionHandler接口，可自定义处理器

二、ThreadPoolExecutor执行顺序

线程池按以下行为执行任务

（1）当线程数小于核心线程数时，创建线程。

（2）当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。

（3）当线程数大于等于核心线程数，且任务队列已满

1）若线程数小于最大线程数，创建线程

2）若线程数等于最大线程数，抛出异常，拒绝任务

三、如何设置参数

默认值

corePoolSize=1

queueCapacity=Integer.MAX_VALUE

maxPoolSize=Integer.MAX_VALUE

keepAliveTime=60s

allowCoreThreadTimeout=false

rejectedExecutionHandler=AbortPolicy()

如何来设置

需要根据几个值来决定

tasks ：每秒的任务数，假设为500~1000

taskcost：每个任务花费时间，假设为0.1s

responsetime：系统允许容忍的最大响应时间，假设为1s

做几个计算

corePoolSize = 每秒需要多少个线程处理？

threadcount = tasks/(1/taskcost) =tasks*taskcout = (500~1000)*0.1 = 50~100 个线程。corePoolSize设置应该大于50

根据8020原则，如果80%的每秒任务数小于800，那么corePoolSize设置为80即可

queueCapacity = (coreSizePool/taskcost)*responsetime

计算可得 queueCapacity = 80/0.1*1 = 80。意思是队列里的线程可以等待1s，超过了的需要新开线程来执行

切记不能设置为Integer.MAX_VALUE，这样队列会很大，线程数只会保持在corePoolSize大小，当任务陡增时，不能新开线程来执行，响应时间会随之陡增。

maxPoolSize = (max(tasks)- queueCapacity)/(1/taskcost)

计算可得 maxPoolSize = (1000-80)/10 = 92

（最大任务数-队列容量）/每个线程每秒处理能力 = 最大线程数

rejectedExecutionHandler：根据具体情况来决定，任务不重要可丢弃，任务重要则要利用一些缓冲机制来处理

keepAliveTime和allowCoreThreadTimeout采用默认通常能满足

以上都是理想值，实际情况下要根据机器性能来决定。如果在未达到最大线程数的情况机器cpu load已经满了，则需要通过升级硬件和优化代码，降低taskcost来处理。

四、C++多线程消息队列？

看什么情况下使用，方法很多。

如果调用频度不高，我做量化分析程序一般是用c++启用python进程，用的pypy速度快点，pypy生成结果到redis或mysql的内存表中，调用结束后c++去redis或mysql的内存表中取出来，你也可以使用文件写入来完成，但文件写入容易出现不同步问题，不想用网络版的，可以用sqlite写入结果，再在另外一个程序用sqlite读取。如果类似互联网业务，可以使用消息队列，消息服务器通信。如果你的程序需要线程安全，需要临界区保护，最好用消息队列这种支持多线程多进程同时访问，消息队列比数据库存储要快，但没有数据库方便。

有个c++版的本机版vedis，高仿redis的嵌入版，你可以用这个初期开发，如果需要切换到redis，很容易修改vedis成redis，ssdb可以把redis落地存储，ssdb是高仿redis的存储版。

如果没有数据存储，可以使用socket通信，或用多进程通信，如chrome是多进程的，通信用的命名管道（Named Pipe），多语言之间调用理论上可以用这个。命名管道要比消息队列快，但需要自己定制。调用方法的协议，可以使用json来完成，这样n多语言都可以通用，如果追求性能可能使用二进制通信协议。

python调用c语言方法也很成熟，但需要自己写一些代码包装一下，需要防止内存泄漏，多线程同步，阻塞，异常等问题。

五、linux多线程详解？

1.进程是操作系统分配资源的基本单位。而线程通俗来讲就是一个进程中一个执行流。

2.这里以串行与并行下载文件举例，如果我们使用串行的方式去下载多个文件，那么得到的结果是，将这些文件逐个按个的下载，即上一个下载完成之后才会下载接下来的文件。

3.如果使用并行的方式下载，那么这些文件就会一次同时下载多个文件，而不是等待上一个下载完后才继续下载接下来的，大大的提高了下载效率。

六、Linux多线程通信？

PIPE和FIFO用来实现进程间相互发送非常短小的、频率很高的消息；

这两种方式通常适用于两个进程间的通信。

共享内存用来实现进程间共享的、非常庞大的、读写操作频率很高的数据（配合信号量使用）；

这种方式通常适用于多进程间通信。

其他考虑用socket。这里的“其他情况”，其实是今天主要会碰到的情况：

分布式开发。

在多进程、多线程、多模块所构成的今天最常见的分布式系统开发中，

socket是第一选择

。消息队列，现在建议不要使用了 ---- 因为找不到使用它们的理由。在实际中，我个人感觉，PIPE和FIFO可以偶尔使用下，共享内存都用的不多了。在效率上说，socket有包装数据和解包数据的过程，所以理论上来说socket是没有PIPE/FIFO快，不过现在计算机上真心不计较这么一点点速度损失的。你费劲纠结半天，不如我把socket设计好了，多插一块CPU来得更划算。另外，进程间通信的数据一般来说我们都会存入数据库的，这样万一某个进程突然死掉或者整个服务器死了，也不至于丢失重要数据、便于回滚到之前的状态。从这个角度考虑，适用共享内存的情况也更少了，所以socket使用得更多。再多说一点关于共享内存的：共享内存的效率确实高，但它的重点在“共享”二字上。如果的确有好些进程共享一大块数据（如果把每个进程都看做是类的对象的话，那么共享数据就是这个类的static数据成员），那么共享内存就是一个不二的选择了。但是在面向对象的今天，我们更多的时候是多线程+锁+线程间共享数据。因此共享进程在今天使用的也越来越少了。不过，在面对一些极度追求效率的需求时，共享内存就会成为唯一的选择，比如高频交易系统。除此以外，一般是不需要特意使用共享内存的。另外，

PIPE和共享内存是不能跨LAN的

（FIFO可以但FIFO只能用于两个进程通信）

。

如果你的分布式系统随着需求的增加而越来越大所以你想把不同的模块放在不同机器上而你之前开发的时候用了PIPE或者共享内存，那么你将不得不对代码进行大幅修改......同时，即使FIFO可以跨越LAN，其代码的可读性、易操作性和可移植性、适应性也远没有socket大。这也就是为什么一开始说socket是第一选择的原因。最后还有个信号简单说一下。

请注意，是信号，不是信号量。

信号量是用于同步线程间的对象的使用的（建议题主看我的答案，自认为比较通俗易懂：

semaphore和mutex的区别？ - Linux - 知乎

）。信号也是进程间通信的一种方式。比如在Linux系统下，一个进程正在执行时，你用键盘按Ctrl+c，就是给这个进程发送了一个信号。进程在捕捉到这个信号后会做相应的动作。虽然信号是可以自定义的，但这并不能改变信号的局限性：

不能跨LAN、信息量极其有限

。在现代的分布式系统中，通常都是

消息驱动：

即进程受到某个消息后，通过对消息的内容的分析然后做相应的动作。如果你把你的分布式系统设置成信号驱动的，这就表示你收到一个信号就要做一个动作而一个信号的本质其实就是一个数字而已。这样系统稍微大一点的话，系统将变得异常难以维护；甚至在很多时候，信号驱动是无法满足我们的需求的。因此现在我们一般也不用信号了。因此，请记住：

除非你有非常有说服力的理由，否则请用socket。

顺便给你推荐个基于socket的轻量级的消息库：ZeroMQ。

七、linux如何停止线程？

杀死线程 所在的进程就可以， ps aux | grep 进程名 kill -TERM 进程号 如果你指的写程序， 那就参考 man pthread_exit。

《Linux就该这么学》里有相关介绍，建议看看。

八、java队列多线程重复执行

Java队列多线程重复执行

在Java编程中，队列是一种常用的数据结构，用于存储和操作元素。多线程编程是一种并发编程技术，可以实现多个线程同时执行任务的目的。本文将探讨如何结合队列和多线程技术实现重复执行任务的功能。

队列

队列是一种先进先出（FIFO）的数据结构，类似于现实生活中的排队。在Java中，可以使用不同的数据结构来实现队列，例如LinkedList、ArrayDeque等。队列通常支持添加元素到队尾、从队首移除元素等操作。

多线程

多线程编程是一种利用计算机多核资源的技术，可以同时执行多个线程，提高程序的性能和效率。在Java中，可以通过继承Thread类或实现Runnable接口来创建多线程程序。

重复执行任务

有时候，我们需要重复执行某个任务，比如定时任务、轮询任务等。结合队列和多线程技术可以很好地实现这一功能。我们可以将任务添加到队列中，然后创建多个线程从队列中取出任务并执行。

以下是一个简单的示例代码，演示如何使用Java队列和多线程实现重复执行任务：

import java.util.Queue; import java.util.concurrent.ArrayBlockingQueue; public class TaskExecutor implements Runnable { private final Queue<Runnable> taskQueue; public TaskExecutor(Queue<Runnable> taskQueue) { this.taskQueue = taskQueue; } @Override public void run() { while (true) { synchronized (taskQueue) { if (!taskQueue.isEmpty()) { Runnable task = taskQueue.poll(); task.run(); } } } } public static void main(String[] args) { Queue<Runnable> taskQueue = new ArrayBlockingQueue<>(10); Thread executor1 = new Thread(new TaskExecutor(taskQueue)); Thread executor2 = new Thread(new TaskExecutor(taskQueue)); executor1.start(); executor2.start(); // Add tasks to the queue taskQueue.add(() -> System.out.println("Task 1 executed")); taskQueue.add(() -> System.out.println("Task 2 executed")); } }

在上面的示例中，我们创建了一个TaskExecutor类来执行任务。两个线程executor1和executor2同时从任务队列中获取任务并执行。通过将任务添加到队列中，我们可以实现任务的重复执行。

总的来说，结合Java队列和多线程技术可以实现高效的重复执行任务功能。通过合理地设计队列数据结构和线程执行逻辑，可以提高程序的性能和可维护性。

希望本文对你理解Java队列多线程重复执行有所帮助！

九、Linux工作队列和等待队列的区别？

工作队列中是即将要调度到的任务队列，等待队列是暂时被挂起的任务队列，或者有些任务无事可做休眠状态的任务，它们会在某些条件触发时恢复换入工作队列并进入执行状态，同样在工作队列中的任务在某个时刻也可以被换入到等待队列中

十、线程池的阻塞队列有哪些？

线程池的阻塞队列有三种，分别是无界队列、有界队列和同步移交队列。其中，无界队列的优点是一直可以添加任务，直到内存耗尽，但缺点是可能会导致OOM异常；有界队列的好处是可以避免OOM异常，但队列满时需要等待；同步移交队列则是一种新的队列实现方式，在队列满时会将任务交给调用者线程去执行，确保任务不会被丢失，但会导致线程池的最大线程数失去作用。此外，还有一种SynchronousQueue同步队列，它不会保存任何任务，在线程池中需要一个空闲的线程来立即执行任务，否则会直接抛出异常。这种队列适用于提高程序的并发性能，但也可能导致线程池的维护成本增加。