原创：生产者和消费者线程内部原理深入解读

最新推荐文章于 2024-05-21 22:13:42 发布
最新推荐文章于 2024-05-21 22:13:42 发布
阅读量67 收藏
点赞数
文章标签： java 爬虫 数据库
原文链接：http://www.cnblogs.com/txq157/p/6428338.html
版权

在多线程编程中，最经典的莫过于生产者和消费者线程了。比如，写一个简易的spider爬虫系统，生产者负责抓取网页，消费者查询网页内容。从内部深入理解运行机制，将会产生质的提升。最多线程开发时，基本流程是先设计公共类，然后设计任务类，包括生产者和消费者，再设计任务调度类，线程同步工具主要从任务调度类传入到任务类，包括CountDownLatch，Future Task，Semaphore等等。之前的一篇解决计算缓存的博客已经提过了。另外在ThreadPoolExecutor源代码的博客中，已经提到过ArrayBlockingQueue这个数据结构。在高级程序的开发中，比如lucene,更多的用CompletionService,它兼具ThreadPoolExecutor和ArrayBlockingQueue,call调用后产生的Future可以存储在ArrayBlockingQueue中，然后通过take方法取出来。这个工具非常好用！在Concurrent包下，由很多底层基于CAS算法的数据结果，包括Atomic，ConcurrentHashMap，队列主要由先进先出的ArrayBlockingQueue,优先级队列PriorityBlockingQueue等。今天主要讲ArrayBlockingQueue的lock机制和生产者消费者实现机制。先看一个图：


生产者向ArrayBlockingQueue中放入产品，消费者从中取出产品。put和take方法分别解决了线程阻塞的问题，当公共集合中的产品已经达到上限时，生产者线程阻塞，同理，当里面没有产品时，消费者线程阻塞。下面从代码角度分析一下原理：

java中的锁包括悲观锁和乐观锁，分别是synchronized和ReentrantLock。前者的性能逊色于后者，后者更具有可伸缩性和高的性能，因为底层调用了CAS算法。

ReentrantLock 是具有与隐式监视器锁定（使用 synchronized 方法和语句访问）相同的基本行为和语义的 Lock 的实现，但它具有扩展的能力。

    作为额外收获，在竞争条件下，ReentrantLock 的实现要比现在的 synchronized 实现更具有可伸缩性。（有可能在 JVM 的将来版本中改进 synchronized 的竞争性能。）

    这意味着当许多线程都竞争相同锁定时，使用 ReentrantLock 的吞吐量通常要比 synchronized 好。换句话说，当许多线程试图访问 ReentrantLock 保护的共享资源时，JVM 将花费较少的时间来调度线程，而用更多个时间执行线程。

    虽然 ReentrantLock 类有许多优点，但是与同步相比，它有一个主要缺点 -- 它可能忘记释放锁定。建议当获得和释放 ReentrantLock 时使用下列结构：

Lock lock = new ReentrantLock();

...

lock.lock();//底层执行CAS操作

try {

  // perform operations protected by lock

}

catch(Exception ex) {

 // restore invariants

}

finally {

  lock.unlock();//千万别忘了释放锁，在lucene排序的源代码中，当搜索处文档后，执行lock.lock(),然后用PriorityQueue排序，最后lock.unlock()

}

CAS无锁算法

要实现无锁（lock-free）的非阻塞算法有多种实现方法，其中 CAS（比较与交换，Compare and swap） 是一种有名的无锁算法。CAS, CPU指令，在大多数处理器架构，包括IA32、Space中采用的都是CAS指令，CAS的语义是“我认为V的值应该为A，如果是，那么将V的值更新为B，否则不修改并告诉V的值实际为多少”，CAS是项乐观锁 技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。CAS无锁算法的C实现如下：

int compare_and_swap (int* reg, int oldval, int newval) 
{
  ATOMIC();
  int old_reg_val = *reg;
  if (old_reg_val == oldval) 
     *reg = newval;
  END_ATOMIC();
  return old_reg_val;
}
CAS（乐观锁算法）的基本假设前提

CAS比较与交换的伪代码可以表示为：

do {   
       备份旧数据；  
       基于旧数据构造新数据；  
} while(!CAS( 内存地址，备份的旧数据，新数据 ))  

就是指当两者进行比较时，如果相等，则证明共享数据没有被修改，替换成新值，然后继续往下运行；如果不相等，说明共享数据已经被修改，放弃已经所做的操作，然后重新执行刚才的操作。容易看出 CAS 操作是基于共享数据不会被修改的假设，采用了类似于数据库的 commit-retry 的模式。当同步冲突出现的机会很少时，这种假设能带来较大的性能提升。

JVM对CAS的支持：AtomicInt, AtomicLong.incrementAndGet()
Java中的原子操作( atomic operations)

原子操作指的是在一步之内就完成而且不能被中断。原子操作在多线程环境中是线程安全的，无需考虑同步的问题。在java中，下列操作是原子操作：

  • all assignments of primitive types except for long and double
  • all assignments of references
  • all operations of java.concurrent.Atomic* classes
  • all assignments to volatile longs and doubles

问题来了，为什么long型赋值不是原子操作呢？例如：

long foo = 65465498L;

实时上java会分两步写入这个long变量，先写32位，再写后32位。这样就线程不安全了。如果改成下面的就线程安全了：

private volatile long foo;

因为volatile内部已经做了synchronized.


以上是补充内容，下面重点研究一下ReentrantLock:

里面有个抽象类Sync，有两个实现：NonfairLock和FairLock,公平锁和非公平锁。在构造器中默认使用非公平锁。关于CLH队列，稍后介绍，先看一下lock方法：lock方法执行逻辑为：当一个线程对公共队列进行操作时，提供底层线程同步支持，先执行CAS算法，如果成功的话，就进行下一步动作，比如take，如果失败了，重新尝试一次，如果成果了，逻辑同上，如果失败了，加入到CLH队列中等待。伪代码如下：

final void lock(){

　　if(compareAndSetState(0,1)){

　　　　setExclusiveOwnerThread(Thread.currentThread());//如果成功了，把当前线程设置为线程持有者，别的线程不能执行了

　　} else {

　　　　acquire(1);

　　}

}

compareAndSetState(0,1)底层调用compareAndSwap(CAS),基本原理这样的：全局变量state初始值为0，当执行lock成功时，把它改为1，当解锁时，再改回0。当由线程进来的时候，先拿0和1进行比较（CAS）。compareAndSetState调用compareAndSwapState(this,sun.misc.unsafe.Unsafe,0,1),这个方法通过unsafe调用本地方法库中的compareAndSwap（CAS）。如果执行CAS失败了，调用acquire（1）方法。传递的参数1意思是先尝试一次CAS,如果还是还是失败的话，加入到CLH中：acquireQueued(addWaiter(Node.ExCLUSIVE)，arg)。CLH的本质是一个双向链表，如果你之前自己实现过双向链表的话，理解起来就非常容易了。把Node节点添加到链表中时，仍然考虑线程同步的问题，还是通过CAS算法，先看一看addWaiter代码：

用图形象地表示一下，Node节点封装了图中的线程状态属性，不是真正的队形，所以起名虚拟队列。这些状态属性非常重要，通过判断信号状态的变化来唤醒队列中的等待线程。

 

直接上传草稿了，以后可以直接看这个图节省时间了，关于源代码的详细解读，不写了，没有这个必要，每个人都有自己的理解。最后要提醒的是，如何解决消费者线程无限等待的问题（当其中一个线程把公共队列中的产品用光了，其他的线程通过take方法只能无限等待下去的问题）。解决办法就是加入"毒丸对象"，说白了就是这个对象不是真这个的产品，只是一个标识而已，当有线程取到最后一个产品时，加入这个标识，改变循环状态，让循环终止，伪代码如下：

run(){

　　boolean done = false;

　　while(!done) {

　　　　产品 = queue.take();

　　　　if(产品 == 标识对象){//注意，此时queue中已经空了，所以把标识对象再放回去

　　　　　　queue.put(标识对象)；

　　　　　　done = true;//改变状态，循环终止

　　　　}

　　　　consumer.consume();//消费者线程消费产品

　　}

}

生产者线程向queue中方产品时，最后也要放入"毒丸对象"。Ok,介绍完毕了！上传简易爬虫spider的代码，体会一下这个原理：

入口：

package httpClient;

public class Test {

    public static void main(String[] args) throws InterruptedException {
        UrlHanding urlHanding = new UrlHanding();
        String []seeds = {"http://www.oschina.net/code/explore/achartengine/client/AndroidManifest.xml",
                "http://www.oschina.net/code/explore","http://www.oschina.net/code/explore/achartengine",
                "http://www.oschina.net/code/explore/achartengine/client","http://map.baidu.com"};
        urlHanding.urlHanding(seeds);//加入种子文件
    }
}

任务调度类：

package httpClient;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
 * 网页抓取
 * @author TongXueQiang
 * @date 2016/05/16
 */
public class UrlHanding {
    private final int THREADS = 10;
    private final ExecutorService producerExecutor = Executors.newSingleThreadExecutor();
    BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
    private final ExecutorService consumerExecutor = new MyThreadPoolExecutor(12, 30, 1000,TimeUnit.MILLISECONDS, q, new ThreadPoolExecutor.CallerRunsPolicy());
    private final CountDownLatch startLatch = new CountDownLatch(1);
    private final CountDownLatch endLatch = new CountDownLatch(THREADS);
    private static UrlQueue queue;
    
    public void urlHanding(String[] seeds) throws InterruptedException {        
        queue = getUrlQueue();
        System.out.println("处理器数量："+Runtime.getRuntime().availableProcessors());
        long start = (long) (System.nanoTime() / Math.pow(10, 9));
        
        producerExecutor.execute(new GetSeedUrlTask(queue,seeds,startLatch));        
        producerExecutor.awaitTermination(100, TimeUnit.MILLISECONDS);
        producerExecutor.shutdown();
        startLatch.await();
        
        UrlDataHandingTask []url_handings = new UrlDataHandingTask[THREADS];
        for (int i = 0;i < THREADS;i++) {
            url_handings[i] = new UrlDataHandingTask(startLatch,endLatch,queue);
            consumerExecutor.execute(url_handings[i]);            
        }
        consumerExecutor.shutdown();
        startLatch.countDown();
        doSomething();
        endLatch.await();
        
        long end = (long) (System.nanoTime() / Math.pow(10,9) - start);
        System.out.println("耗时： " + end + "秒");
    }

    private void doSomething() {
        
        
    }

    private UrlQueue getUrlQueue() {
        if (queue == null) {
            synchronized(UrlQueue.class){
                if (queue == null) {
                    queue = new UrlQueue();
                    return queue;
                }
            }
        }
        return queue;
    }
}
生产者任务类：

package httpClient;

import java.util.concurrent.CountDownLatch;

public class GetSeedUrlTask implements Runnable {
    private UrlQueue queue;
    private String[] seeds;
    private CountDownLatch startLatch;
    
    public GetSeedUrlTask(UrlQueue queue, String[] seeds,CountDownLatch startLatch) {
        this.queue = queue;
        this.seeds = seeds;
        this.startLatch = startLatch;
    }

    public void addUrl() {
        try {
            for (String url : seeds) {
                queue.addElem(url);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    @Override
    public void run() {
        addUrl();        
        try {
            queue.addElem("www.baidu.com");//鍔犲叆"姣掍父瀵硅薄"
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        startLatch.countDown();
    }

}
消费者任务类：

package httpClient;

import java.util.concurrent.CountDownLatch;

public class UrlDataHandingTask implements Runnable {
    private CountDownLatch startLatch;
    private CountDownLatch endLatch;
    private UrlQueue queue;

    public UrlDataHandingTask(CountDownLatch latch, CountDownLatch endLatch, UrlQueue queue) {
        this.startLatch = latch;
        this.endLatch = endLatch;
        this.queue = queue;        
    }

    /**
     * 下载对应的页面并抽取出链接，放入待处理队列中
     * @param url
     * @throws InterruptedException
     */
    public void dataHanding(String url) throws InterruptedException {
        getHrefOfContent(DownPage.getContentFromUrl(url));
        for (String url0 : VisitedUrlQueue.visitedUrlQueue) {
            System.out.println(url0);
        }
    }

    @Override
    public void run() {
        try {
            startLatch.await();
        } catch (InterruptedException e1) {
            Thread.currentThread().interrupt();
        }

        while (!queue.isEmpty()) {
            try {
                String url = queue.outElem();
                if ("www.baidu.com".equals(url.trim())) {
                    queue.addElem(url);
                    break;
                }
                dataHanding(url);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        endLatch.countDown();
    }

    /**
     * 获取页面源代码中的超链接
     *
     * @param content
     * @throws InterruptedException
     */
    public void getHrefOfContent(String content) throws InterruptedException {
        System.out.println("开始");
        String[] contents = content.split("<a href=\"");
        for (int i = 1; i < contents.length; i++) {
            int endHref = contents[i].indexOf("\"");
            String aHref = FunctionUtils.getHrefOfInOut(contents[i].substring(0, endHref));
            if (aHref != null) {
                String href = FunctionUtils.getHrefOfInOut(aHref);
                if (queue.isContains(href) && !VisitedUrlQueue.isContains(href)
                        && href.indexOf("/code/explore") != -1) {
                    // 放入待抓取队列中
                    queue.addElem(href);
                }
            }
        }
        System.out.println(queue.size() + "--抓取到的连接数");
        System.out.println(VisitedUrlQueue.size() + "--已处理的页面数");
    }

}

utils中的类：

package httpClient;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class FunctionUtils {
    //匹配超链接的正则表达式
    private static String pat = "http://www\\.oschina\\.net/code/explore/.*/\\w+\\.[a-zA-Z]+";
    private static Pattern pattern = Pattern.compile(pat);
    private static BufferedWriter writer = null;
    //爬虫搜索深度
    private static int depth = 0;
    /**
     * 以"/"来分割URL,获得超链接的元素
     * @param url
     * @return
     */
    public static String[] divUrl(String url){
        return url.split("/");
    }    
    /**
     * 判断能否创建文件
     * @param url
     * @return
     */
    public static boolean isCreateFile(String url){
        Matcher matcher = pattern.matcher(url);
        return matcher.matches();
    }
    /**
     * 创建对应文件
     * @param content
     * @param urlPath
     */
    public static void createFile(String content,String urlPath){
        //1.分割url
        String []elems = divUrl(urlPath);
        //2.拼接文件路径
        StringBuffer path = new StringBuffer();
        File file = null;
        for (int i = 1;i < elems.length;i++) {
            if (i != elems.length - 1) {
                path.append(elems[i]);
                path.append(File.separator);
                file = new File("E:" + File.separator + path.toString());
            }
            if (i == elems.length - 1) {
                Pattern pattern = Pattern.compile("\\w+\\.[a-zA-Z]");
                Matcher matcher = pattern.matcher(elems[i]);
                if (matcher.matches()) {
                    if (!file.exists()) {
                        file.mkdirs();
                    }
                    String []fileName = elems[i].split("\\.");
                    file = new File("E:" + File.separator + path.toString() + File.separator + fileName[0] + ".txt");
                }
                System.out.println("文件名称："+ file.getName().toString());
                    try {
                        writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file)),512);
                        try {
                            writer.write(content);
                            writer.newLine();
                            writer.flush();
                            //writer.close();
                            System.out.println("创建文件成功");
                        } catch (IOException e) {                            
                            e.printStackTrace();
                        }
                        
                    } catch (FileNotFoundException e) {                        
                        e.printStackTrace();
                    }
                
            }
        }
    }
    /**
     * 获取页面的超链接并将其转换为正式的A标签
     * @param href
     * @return
     */
    public static String getHrefOfInOut(String href){
        String resultHref = null;
        if (href.startsWith("http://")) {//判断是否为外部链接
            resultHref = href;
        } else {
            if (href.startsWith("/")) {//为内部链接
                resultHref = "http://www.oschina.net" + href;
            }
        }
        return resultHref;
    }
    /**
     * 截取网页源文件的目标内容
     * @param content
     * @return
     */
    public static String getGoalContent(String content){
        String signContent = content.substring(content.indexOf("<pre class=\""));
        return signContent.substring(signContent.indexOf(">")+1, signContent.indexOf("</pre>"));
    }
    /**
     * 判断网页源文件是否含有目标文件
     * @param content
     * @return
     */
    public static int isHasGoalContent(String content){
        return content.indexOf("<pre class=\"");
    }
}
下载网页类：

package httpClient;

import java.io.IOException;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;

public class DownPage {
    /**
     * 根据url抓取网页内容
     * @param url
     * @return
     */
    public static String getContentFromUrl(String url){
        HttpClient client = new DefaultHttpClient();
        HttpGet getHttp = new HttpGet(url);
        String content = null;
        HttpResponse response;
        try {
            response = client.execute(getHttp);
            HttpEntity entity = response.getEntity();
            //把url加入到已抓取队列中
            VisitedUrlQueue.addElem(url);
            //转化为文本信息
            if (entity != null) {
                content = EntityUtils.toString(entity);
                System.out.println(content);
                System.out.println("-------------->>>");
                if (FunctionUtils.isCreateFile(url) && FunctionUtils.isHasGoalContent(content) != -1) {
                    //创建文件
                    FunctionUtils.createFile(FunctionUtils.getGoalContent(content), url);
                }
            }
        } catch(ClientProtocolException e){
            e.printStackTrace();
        }
        catch (IOException e) {            
            e.printStackTrace();
        }
        finally {
            client.getConnectionManager().shutdown();
        }
        return content;
    }
}
外部分装的公共产品类：

package httpClient;

import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;

public class UrlQueue {
    public final Queue<String> urlQueue = new ArrayBlockingQueue<String>(10);
    public final int MAX_SIZE = 10000;
    
    public void addElem(String url) throws InterruptedException{
        ((ArrayBlockingQueue<String>) urlQueue).put(url);
    }
    
    public String outElem() throws InterruptedException{
        return ((ArrayBlockingQueue<String>) urlQueue).take();
    }
    
    public boolean isContains(String url){
        return urlQueue.contains(url);
    }
    
    public int size(){
        return urlQueue.size();
    }
    
    public boolean isEmpty(){
        return urlQueue.isEmpty();
    }
}

package httpClient;

import java.util.Set;
import java.util.concurrent.ConcurrentSkipListSet;

public class VisitedUrlQueue {
    public static Set<String> visitedUrlQueue = new ConcurrentSkipListSet<String>();
    
    public synchronized static void addElem(String url){
        visitedUrlQueue.add(url);
    }
    
    public synchronized static boolean isContains(String url){
        return visitedUrlQueue.contains(url);
    }
    
    public static int size(){
        return visitedUrlQueue.size();
    }
}

另外还有自定义扩展的TheadPoolExecutor：

package httpClient;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Logger;

/**
 * 自定义线程池,实现计时和统计功能，并且自定义有界队列以及饱和策略
 * @author TongXueQiang
 * @date 2016/05/19
 */
public class MyThreadPoolExecutor extends ThreadPoolExecutor {
    private final ThreadLocal<Long> startTime = new ThreadLocal<Long>();
    private final Logger log = Logger.getLogger("MyThreadPoolExecutor");
    private final AtomicLong numTasks = new AtomicLong(1);
    private final AtomicLong totalTime = new AtomicLong();
    
    public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
            BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);        
    }
    /**
     * 任务执行前
     */
    protected void beforeExecute(Thread t,Runnable r){
        super.beforeExecute(t, r);
        log.fine(String.format("Thread %s: start %s",t,r));
        startTime.set((long)(System.nanoTime()/Math.pow(10, 9)));
    }
    /**
     * 任务执行后
     * @param r 任务
     * @param t 执行任务的线程
     */
    protected void afterExecutor(Runnable r,Throwable t){
        try {
            Long endTime = (long) (System.nanoTime() / Math.pow(10,9));
            Long taskTime = endTime - startTime.get();
            numTasks.incrementAndGet();
            totalTime.addAndGet(taskTime);
            log.fine(String.format("Thread %s: end%s,time=%ds", taskTime));
        } finally {
            super.afterExecute(r, t);
        }
    }
    
    protected void terminated () {
        try {
            log.info(String.format("Terminated: avg time=%ds", totalTime.get() / numTasks.get()));
        } finally {
            super.terminated();
        }        
    }
}

佟氏出品，必属精品！坚持研究最底层的技术，坚持理论与编程结合，坚持写高质量代码，努力提升学术水平，尤其是机器学习算法的理论研究与创新，坚持阅读英文原版的学术论文，坚持原创，坚持独立思考！下一篇博客，上传一篇周国平的文章，具有很大的启发性，尤其是在互联网这样一个比较大的浮躁的环境下，所有的程序员和公司都应该深刻反省，什么才叫个性，什么叫成熟。怎样把自己的理念与企业文化融入到产品中，打造个性的产品，创造价值而不只是传播价值！

 

转载于:https://www.cnblogs.com/txq157/p/6428338.html

weixin_30414305
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入多线程之:深入生产者、消费者队列分析
09-05
本篇文章是对生产者与消费者队列进行了详细的分析介绍，需要的朋友参考下
线程基本原理-生产者-消费者问题
yuezheyue123的博客
06-15 482
生产者-消费者问题就是线程协作的问题，notify通知的时候，会先唤醒等待时间最长的对象，因此不用担心自己唤醒自己的情况。 public static void main(String[] args) { Baozi baozi = new Baozi(); baozi.flag = false; Chihuo Chihuo = new Chihuo("吃货", baozi); Chihuo.start(); Baozipu
线程池原理——生产者/消费者
小强快跑~~
06-09 308
import java.util.ArrayList; import java.util.List; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; /** * 简化的线程池，仅用来说明工作原理.<br> * @author gongqiang <br> * @version 1.0.0 2021年6月9日<br> * @se.
消费者与生产者的线程之间同步操作
jxm_96的博客
10-30 891
实验目的通过编写经典的“生产者-消费者”问题的实验，进一步熟悉Linux中的多线程编程，并且掌握用信号量处理线程间的同步和互斥问题。 实验内容“生产者–消费者”问题描述如下：有一个有限缓冲区（这里用有名管道实现FIFO式缓冲区）和两个线程：生产者和消费者，它们不停地把产品放入缓冲区和从缓冲区拿走产品。一个生产者在缓冲区满的时候必须等待，一个消费者在缓冲区空的时候也必须等待。另外，因为缓冲区是临界资源
生产者消费者-线程-链表-队列实现
he_0123的专栏
01-04 604
生产者消费者-线程-链表-队列实现链表实现#include<stdio.h> #include<pthread.h> #include<stdlib.h> #include<unistd.h>pthread_mutex_t lock; pthread_cond_t cond; struct node { int iValue; struct node *next; }*head =
12.2 Qt5多线程：使用信号量实现生产者和消费者
02-15
Qt5多线程，使用QSemaphore类实现生产者和消费者问题。
Linux线程编程之生产者消费者问题
12-14
　本文基于顺序循环队列，给出Linux生产者/消费者问题的多线程示例，并讨论编程时需要注意的事项。文中涉及的代码运行环境如下： 　本文假定读者已具备线程同步的基础知识。 　一 顺序表循环队列 　1.1 ...
Java多线程-生产者与消费者问题
02-03
Java多线程--生产者与消费者问题
C#多线程学习之(三)生产者和消费者用法分析
01-21
本文实例讲述了C#多线程学习之生产者和消费者用法。分享给大家供大家参考。具体实分析如下： 前面的文章说过，每个线程都有自己的资源，但是代码区是共享的，即每个线程都可以执行相同的函数。这可能带来的问题就是...
jar包增量更新分析
junlaiyan的专栏
05-16 379
借助jdeps分析出jar包的增量文件
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 222
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
命令执行漏洞（二）
XLbb的博客
05-15 1011
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 349
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1077
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
Spring6基础笔记
最新发布
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 681
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Android Model引入其他aar包 导致无法打包成aar
qq_27400335的博客
05-16 375
Android Model引入其他aar包 导致无法打包成aar
SpringBoot事件发布与监听，观察者模式使用
小哇
05-16 258
可以发现，用户注册与信息推送强耦合，用户注册其实到存库成功，就已经算是完成了，后面的信息推送都是额外的操作，甚至信息推送失败报错，还会影响API接口的结果，如果在同一事务，报错信息不捕获，还会导致事务回滚，存库失败。本文记录springboot使用@EventListener监听事件、ApplicationEventPublisher.publishEvent发布事件实现业务解耦。
Java基础——字符串
Kenard的博客
05-17 958
基本数据类型、包装类 转成字符串，调用String类的public String valueOf(int n)可将int型转换为字符串相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(doubled)、valueOf(boolean b)可由参数的相应类型到字符串的转换。下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。
多线程技术解决生产者消费者原理
05-17
在多线程环境下，生产者和消费者可能会同时运行，因此需要考虑线程安全性和同步问题。以下是一种常见的解决方案： 1. 定义一个共享的缓冲区，用于生产者将数据放入、消费者从中取出。 2. 定义一个计数器，用于记录...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值