程序员
程序员

生产者与消费者(多线程经典案例)

生产者与消费者(多线程经典案例)

注：此示例来自MLDN讲师李兴华JAVA SE基础教学部分

生产者和消费者是多线程中一个经典的操作案例下面一起看下代码：

示例一：

package  org.lx.multithreading;

 /**
 * 定义一个信息类
 *  @author  Solitary
  */
class  Info {    
     private  String name  =   " 罗星 "  ;             // 定义name属性        
     private  String content  = " JAVA初学者 " ;     // 定义content属性
    
     // getter     setter
     public  String getName() {
         return  name;
    }
     public   void  setName(String name) {
         this .name  =  name;
    }
     public  String getContent() {
         return  content;
    }
     public   void  setContent(String content) {
         this .content  =  content;
    }
} ;

 /**
 * 定义生产者
 *  @author  Solitary
  */
class  Producer  implements  Runnable {     // 通过接口Runnable实现多线程
     private  Info info  =   null  ;             // 保存Info引用
    
     public  Producer(Info info) {         // 通过构造方法传递引用
         this .info  =  info ;
    }
    
    @Override
     public   void  run() {
         boolean  flag  =   false  ;                 // 定义标志位            
         for ( int  i  =   0 ; i  <   50 ; i ++ ) {         // 生产50次信息
             if (flag){     // 如果标志位为true 将设置 中文内容
                 this .info.setName( " 小星 " ) ;     // 设置名字
                 try  {
                     // 为了更好的体现代码运行效果在设置姓名和内容之间加入延迟操作
                    Thread.sleep( 300 ) ;
                }  catch  (InterruptedException e) {         // 线程被打断后会抛出此异常
                    e.printStackTrace();
                }            
                 this .info.setContent( " JAVA初学者 " ) ;         // 设置内容
                flag  =   false  ;     // 改变标志位，用于变换输入内容
                
            } else {     // 如果标志位为false 将设置英文内容        
                 this .info.setName( " Solitary " ) ;     // 设置名字
                 try  {
                     // 为了更好的体现代码运行效果在设置姓名和内容之间加入延迟操作
                    Thread.sleep( 300 ) ;
                }  catch  (InterruptedException e) {         // 线程被打断后会抛出此异常
                    e.printStackTrace();
                }            
                 this .info.setContent( " Coder " ) ;         // 设置内容
                flag  =   true  ;     // 改变标志位，用于变换输入内容
            }
        }
    }    
    
} ;

 /**
 * 定义消费者
 *  @author  Solitary
  */
class  Consumer  implements  Runnable {
     private  Info info  =   null  ;         // 用于保存Info引用,其目的是为了让消费者和生产者拥有同一个info
    
     public  Consumer(Info info){
         this .info  =  info ;
    }
     public   void  run() {
         for ( int  i  =   0 ; i  <   50 ; i ++ ) {         // 消费和也从info中取50次消息
             try  {
                Thread.sleep( 300 ) ;
            }  catch  (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println( this .info.getName()  +  
                     "  -->  "   +   this .info.getContent()) ;
        }
    }
} ;

 /**
 * 测试代码
 *  @author  Solitary\
  */
public   class  MultiThreadingDemo01 {
     public   static   void  main(String args[]){        
        Info info  =   new  Info() ;     //  实例化Info对象
        Producer pro  =   new  Producer(info) ;         //  生产者
        Consumer con  =   new  Consumer(info) ;         //  消费者
         new  Thread(pro).start() ;         // 启动线程
         new  Thread(con).start() ;         // 启动线程        
    }
}
示例一（执行效果）：
小星  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
Solitary  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  JAVA初学者
小星  -->  JAVA初学者
Solitary  -->  Coder
Solitary  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  Coder
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
Solitary  -->  JAVA初学者
小星  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
Solitary  -->  JAVA初学者
Solitary  -->  JAVA初学者
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  JAVA初学者
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  JAVA初学者
小星  -->  JAVA初学者
请注意运行结果，为什么我代码里面明明成对设置的是：小星 --> JAVA初学者;  Solitary --> Coder而运行结果确实有不匹配的呢？
分析：
因为生产者和消费者的线程都已启动，那么不能保证谁在前，或者谁在后，在生产者还在设置内容的时候（比如：已经设置好的Info的name=小星,Context=JAVA初学者，而此时生产者又设置了name = Solitary正打算设置Content = Coder），而消费者已经取走了内容，那么显示的肯定就是Solitary --> JAVA初学者这样的结果，因为两个线程都在这执行着，出现了不匹配的结果。可以将代码修改为：

示例二
package  org.lx.multithreading;

 /**
 * 定义一个信息类
 *  @author  Solitary
  */
class  Info {    
     private  String name  =   " 罗星 "  ;             // 定义name属性        
     private  String content  = " JAVA初学者 " ;     // 定义content属性
    
     // getter     setter
     public  String getName() {
         return  name;
    }
     public   void  setName(String name) {
         this .name  =  name;
    }
     public  String getContent() {
         return  content;
    }
     public   void  setContent(String content) {
         this .content  =  content ;
    }
    
     public   synchronized   void  set(String name, String content){         // 由此方法统一设置信息
         this .setName(name) ;
         try  {
             /*  此时这个地方加不加延迟没有任何关系，因为该方法已经同步
               在执行到此方法（get()）时，此方法将会完整结束后才会执行
               到别的方法 ,所以一定会完整设置完信息之后才会轮到信息的读取方法 */
            Thread.sleep( 300 ) ;            
        }  catch  (InterruptedException e) {
            e.printStackTrace();
        }
         this .setContent(content) ;
    }
    
     public   synchronized   void  get(){
         try  {
            Thread.sleep( 300 ) ;
        }  catch  (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println( this .getName()  +  
                 "  -->  "   +   this .getContent()) ;
    }
} ;

 /**
 * 定义生产者
 *  @author  Solitary
  */
class  Producer  implements  Runnable {     // 通过接口Runnable实现多线程
     private  Info info  =   null  ;             // 保存Info引用
    
     public  Producer(Info info) {         // 通过构造方法传递引用
         this .info  =  info ;
    }
    
    @Override
     public   void  run() {
         boolean  flag  =   false  ;                 // 定义标志位            
         for ( int  i  =   0 ; i  <   50 ; i ++ ) {         // 生产50次信息
             if (flag){     // 如果标志位为true 将设置 中文内容
                 this .info.set( " 小星 " ,  " JAVA初学者 " ) ;
                flag  =   false  ;     // 改变标志位，用于变换输入内容
                
            } else {     // 如果标志位为false 将设置英文内容        
                 this .info.set( " Solitary " ,  " Coder " ) ;
                flag  =   true  ;     // 改变标志位，用于变换输入内容
            }
        }
    }    
    
} ;

 /**
 * 定义消费者
 *  @author  Solitary
  */
class  Consumer  implements  Runnable {
     private  Info info  =   null  ;         // 用于保存Info引用,其目的是为了让消费者和生产者拥有同一个info
    
     public  Consumer(Info info){
         this .info  =  info ;
    }
     public   void  run() {
         for ( int  i  =   0 ; i  <   50 ; i ++ ) {         // 消费和也从info中取50次消息
             this .info.get() ;
        }
    }
} ;

 /**
 * 测试代码
 *  @author  Solitary\
  */
public   class  MultiThreadingDemo01 {
     public   static   void  main(String args[]){        
        Info info  =   new  Info() ;     //  实例化Info对象
        Producer pro  =   new  Producer(info) ;         //  生产者
        Consumer con  =   new  Consumer(info) ;         //  消费者
         new  Thread(pro).start() ;         // 启动线程
         new  Thread(con).start() ;         // 启动线程        
    }
}
示例二（运行效果）
Solitary  -->  Coder
Solitary  -->  Coder
Solitary  -->  Coder
Solitary  -->  Coder
Solitary  -->  Coder
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
Solitary  -->  Coder
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
小星  -->  JAVA初学者
观察运行结果发现，不匹配的现象已经解决了，因为设置name 与 content 的步骤都在一个同步方法中，所以不会导致设置不完整的情况，但是并没有达到我们想要的结果， 观察出现了连续出现重复的内容，这是为什么呢？ 分析：这两个方法在不同的线程中，当一条线程中的方法设置完内容之后，另一个线程取出内容显示，取完之后当了土财主不让，继续取，生产者无法更新里边的内容，那显示出来的内容肯定就是重复的，因为多线程中，不能保证这个线程什么时候执行。怎样解决呢？

1.中间那块矩形代表信息载体Info实例，载体中没有产品的时候上面显示为绿灯，那么这时生产者能放入产品。而消费者不能取出产品。

2.当生产者放入产品之后灯变成红色，这时候生产者将不能放入产品，而轮到消费者取出产品，那么去完之后再次改变灯为绿色。这样一直反复执行下去。

那么载体上的那盏灯属于一个标志位，我们可以在代码中用boolean表示，那么这盏灯是属于信息载体Info的标志，因为设置/取出这两个方法都在Info中定义，生产者与消费者只是负责调用Info之中的方法，就让Info中的方法判断一下自身的标志位的状态判断是否生产或者取出。

实例三
package  org.lx.multithreading ;

 class  Info         // 定义信息类
{
     private  String name  =   " 罗星 "  ;         // 定义name属性
     private  String content  =   " JAVA初学者 "  ;         // 定义content属性
     private   boolean  flag  =   false  ;     // 设置标志位


     public   synchronized   void  set(String name, String content){
         if ( ! flag){         // 方法每次执行的时候都检查一下标志位状态，从而判断时候进行生产
             try {
                 super .wait() ;
            } catch (InterruptedException e){
                e.printStackTrace() ;
            }
        }
         this .setName(name) ;         // 设置名称
         try {
            Thread.sleep( 300 ) ;
        } catch (InterruptedException e){
            e.printStackTrace() ;
        }
         this .setContent(content) ;     //  设置内容
        flag  =   false  ;         // 改变标志位,表示可以取走
         super .notify() ;     // 唤醒线程
    }

     public   synchronized   void  get(){
         if (flag){         //// 方法每次执行的时候都检查一下标志位状态，从而判断时候进行取出
             try {
                 super .wait() ;
            } catch (InterruptedException e){
                e.printStackTrace() ;
            }
        }
         try {
            Thread.sleep( 300 ) ;
        } catch (InterruptedException e){
            e.printStackTrace() ;
        }
        System.out.println( this .getName()  +
                 "  -->  "   +   this .getContent()) ;
        flag  =   true  ;     // 改变标志位,表示可以生成    
         super .notify() ;
    }

     public   void  setName(String name){
         this .name  =  name ;
    }

     public  String getName(){
         return   this .name ;
    }

     public   void  setContent(String content){
         this .content  =  content ;
    }

     public  String getContent(){
         return   this .content ;
    }
}

 class  Producer  implements  Runnable         // 通过Runnable实现多线程
{
     public  Info info  =   null  ;         // 保存Info引用
     public  Producer(Info info){
         this .info  =  info ;
    }

     public   void  run(){
         boolean  flag  =   false  ;     // 定义标记位
         for ( int  i  =   0 ; i  <   50 ; i ++ ){
             if (flag){
                 this .info.set( " 罗星 " ,  " JAVA初学者 " ) ;
                flag  =   false  ;
            } else {
                 this .info.set( " Solitary " ,  " Coder " ) ;
                flag  =   true  ;
            }
        }
    }
} ;

 class  Consumer  implements  Runnable{         // 消费者类
     private  Info info  =   null  ;        
     public  Consumer(Info info){
         this .info  =  info ;
    }

     public   void  run(){
         for ( int  i  =   0 ; i  <   50 ; i ++ ){
             this .info.get() ;
        }
    }
} ;

 // 测试代码
public   class  MultiThreading
{
     public   static   void  main(String[] args){
        Info info  =   new  Info() ;     // 实例化Info对象
        Producer pro  =   new  Producer(info) ;     // 生产者
        Consumer con  =   new  Consumer(info) ;     // 消费者
         new  Thread(pro).start() ;
         new  Thread(con).start() ;
    }
}
在此利用了Object类对线程的支持，Object中定义了方法：
public final void wait() throws InterruptedException
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。

当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。 

public final void notify()
唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。  

当生产者线程调用此方法时，首先检查一下标志位，判断是否等待，此时消费者也在调用相应方法判断是否取出，如果可以取出，那么取出后改变标志位的状态，然后唤醒该对象中等待的线程，这时状态改变生产者既进行生产操作。


序言：
小弟是一个JAVA新手，这也是第一次写博客，此文纯属于学习笔记，以便日后复习，如果前辈们认为描述有错误的地方，或者觉得不清晰感觉思路混乱的地方，还请前辈们多多赐教，晚生感激不胜！ 谢谢。

你可能感兴趣的:(生产者与消费者(多线程经典案例))

  • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】 还算善良_ 私有代码库工具类javalist数据结构
    packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
  • C语言演示多线程编程条件下自旋锁和屏障的使用 嫦娥妹妹等等我 开发语言c语言开源
    主线故事:有4个人玩游戏输了,惩罚:1分别使用4台不同的ATM机给我存钱2必须一块一块的存3存完还得在ATM上看一下我的余额设计模式:1每个人使用一条单独的线程,再准备一个计时线程用来输出时间2存钱涉及到对共享资源的读写,是原子操作需要用锁保护这里使用自旋锁3都存完钱后需要等待在各自的ATM上回显余额这里使用屏障技术4如果在主线程中回显对应他们给我打电话告诉我存完了我自己看一下则不需要使用屏障因为
  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
  • 突破编程_C++_C++11新特性（多线程编程的原子操作（2）） breakthrough_01 c++算法
    1std::atomic的加载与存储操作加载和存储操作是std::atomic最基础的两种操作。加载操作加载操作是通过load成员函数实现的，它用于从原子变量中读取一个值。这个函数可以确保在读取过程中，不会被其他线程打断。std::atomicatomic_var(10);//初始化一个原子变量，初始值为10intvalue=atomic_var.load();//原子加载操作，将atomic_v
  • list分组，多线程处理数据入库 墨玉加菲 java后端javaspring
    需求：解析上传的文件，将文件里的数据放入到list后，验证数据，符合条件的数据入库，分组多线程处理数据，有异常回滚事务（这里使用的是手动事务）先贴代码，这是业务代码packagecom.sh.service.test.impl;importcom.baomidou.mybatisplus.extension.service.impl.ServiceImpl;importcom.sh.constan
  • Java学习笔记：atomic的实现原理？ 曲钟人散
    在多线程的场景中，我们需要保证数据安全，就会考虑同步的方案，通常会使用synchronized或者lock来处理，使用了synchronized意味着内核态的一次切换。这是一个很重的操作。有没有一种方式，可以比较便利的实现一些简单的数据同步，比如计数器等等。concurrent包下的atomic提供我们这么一种轻量级的数据同步的选择。classMyThreadimplementsRunnable{
  • 无锁队列（Lock-Free Queue） 笨死de猪 游戏服务器架构开发语言c++无锁队列
    一、什么是无锁队列无锁队列（Lock-FreeQueue）是一种不使用锁机制（如互斥锁或读写锁）来实现线程安全的数据结构，是lock-free中最基本的数据结构。它通过复杂的原子操作（如CAS操作，在C++中，可以使用std::atomic库提供的原子操作）来确保在多线程环境下的正确性和一致性。无锁队列的设计目标是在高并发场景下提供高性能的入队和出队操作，避免了锁机制带来的性能开销和潜在的死锁问题
  • 认识Java语言（一） 小魏冬琅 学习java开发语言
    Java语言的背景(0.1)在数字化的时代浪潮中，Java显得尤为璀璨，它不仅仅是由SunMicrosystems公司孕育而出的一种编程语言，更是一种融汇简洁性、面向对象的设计、分布式编程能力、稳健与安全性、平台独立性、可移植性、多线程处理能力和动态性于一体的技术精粹。Java之所以独树一帜，得益于它那“一次编写，随处运行”的核心理念，使其不仅成为编程语言的代名词，更是一个全方位的开发平台，提供了
  • MySQL Enterprise Backup (MEB) for MySQL 8.0 深入解析及企业级备份恢复演练 lzyever MySQLmysql数据库
    一、备份恢复核心概念MEB简介MySQLEnterpriseBackup是Oracle提供的专业物理备份工具，专为MySQL8.0及以后版本设计，提供高效且低干扰的在线备份解决方案。它能够实现对InnoDB存储引擎数据的快速备份，并兼容MySQL的诸多高级特性。主要特点在线热备份:MEB在备份期间尽可能减少对数据库活动的阻塞，采用多线程技术并结合InnoDB的元组锁定机制，创建一致性备份。增量备份
  • 安卓面试题多线程 81-85 ️ 邪神 Android面试题java开发语言Android面试面试题多线程
    81.共享变量在多线程下如何保证线程安全？因为多线程是交替执⾏，每个线程操作共享变量时可能会导致数据不⼀致，要确保线程安全，需要在访问共享变量时添加同步机制。当然，如果这个变量本⾝是线程安全的，⽐如AtomicLong，那么多线程访问也是安全的82.Java中是否共享变量都使⽤类似AtomicLong原⼦安全类，多线程访问就是安全的？这个不确定，因为⽆法保证多个变量同时操作，⼀个原⼦变量可以保证⾃
  • 服务器硬件基础知识 love6a6 服务器
    服务器硬件是支持服务器运行的基础设施，它与普通的个人电脑硬件有所不同，主要表现在以下几个方面：一、中央处理器（CPU）：服务器CPU往往支持多线程和多核心，以满足同时处理多个请求的需要。服务器CPU的类型多种多样，它们根据性能、核心数量、线程数量、功耗和价格等因素进行分类。以下是一些常见的服务器CPU类型：x86架构：这是目前最常见的服务器CPU架构，由英特尔和AMD公司生产。支持32位和64位运
  • Python中的并发编程：多线程与多进程的比较【第124篇—多线程与多进程的比较】 一键难忘 pythonjava服务器并发编程多线程多进程
    发现宝藏前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。【点击进入巨牛的人工智能学习网站】。Python中的并发编程：多线程与多进程的比较在Python编程领域中，处理并发任务是提高程序性能的关键之一。本文将探讨Python中两种常见的并发编程方式：多线程和多进程，并比较它们的优劣之处。通过代码实例和详细的解析，我们将深入了解这两种方法的适用场景和潜在问题。多线程
  • 经典案例- 磁盘阵列两块盘掉线的数据恢复分析 北亚数据恢复 数据恢复数据恢复raid阵列数据恢复服务器
    磁盘阵列两块硬盘离线数据恢复案例一：客户使用Dell2850服务器组建了raid5磁盘阵列，阵列中包含有6块硬盘（SCSI硬盘，单盘容量300G），服务器操作系统为linuxRedhat4；文件系统为ext3文件系统。在使用过程中服务器瘫痪，管理员对阵列检查后发现有两块硬盘离线，对其中一块硬盘进行了强制上线操作，但操作系统启动异常。管理员此时意识到事情的严重程度，马上对服务器进行关机，然后联系到数
  • 【JavaEE -- 多线程进阶 - 面试重点】 水冠7 JavaEEjava-ee面试java
    多线程进阶1.常见锁策略1.1乐观锁和悲观锁1.2轻量级锁和重量级锁1.3自旋锁和挂起等待锁synchronized具有自适应能力1.4普通互斥锁和读写锁1.5公平锁和非公平锁1.6可重入锁和不可重入锁2.Synchronized原理（特点、加锁过程、自适应）2.1Synchronized基本特点2.2Synchronized加锁过程2.3锁消除2.4锁粗化3.CAS（compareandswap
  • 【C++】C++多线程资料总目录 bdview c++多线程javalinuxpython
    目录基础知识编程实践编码线程同步性能资源测试和调试注意事项基础知识【多线程】c++11多线程编程(一)——初识https://blog.csdn.net/bandaoyu/article/details/106084199【多线程】c++11多线程编程(二)——理解线程类的构造函数_bandaoyu的笔记-CSDN博客【多线程】c++11多线程编程(三)——竞争条件与互斥锁https://blog
  • JUC多线程与高并发（一） JasonHuan1123 计算机类linuxjavajvm缓存
    1.谈谈对volatile的理解volatile是java虚拟机提供的一种轻量级的同步机制保证可见性不保证原子性禁止指令重排相当于轻量级的sychronized1.1.JMM的理解JMM，java内存模型JavaMemoryModel，是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。JMM关于同步的
  • 开源数据库 OpenGauss 的 SQL 解析源码分析 openGaussMan 网络openGauss数据库
    开源数据库OpenGauss的SQL解析源码分析openGauss数据库体系概述openGauss是关系型数据库，采用客户端/服务器，单进程多线程架构；支持单机和一主多备部署方式，同时支持备机可读、双机高可用等特性。从代码结构体系结构的角度来说，oepnGauss的第一个组成部分是通信管理。openGauss查询响应是使用“单个用户对应一个服务器线程”的简单客户端/服务器模型实现的。由于我们无法预
  • Unity3D多线程UI之滚动框数据和模型绑定 胡强_79a4
    先附上git地址https://github.com/huqiang0204/huqiang.UnitySubThreadUI首先声明一个需要反射的模型类classItem//模型UI可自行定制{publicTextElementText;}然后创建一个数据集合，可以是IList，Array和FakeArray声明一组数据，并且绑定到滚动框上ListtestData=newList();//数据的
  • 懒汉式和饿汉式单例模式以及解决单例的线程不安全 橙哥分享 java面试单例模式java开发语言
    懒汉式和饿汉式是两种常见的单例模式实现方式，它们分别在不同情况下进行单例对象的初始化。以下是关于懒汉式和饿汉式单例模式的简要解释：1.懒汉式单例模式概念：懒汉式单例模式是指在首次使用时才会创建单例对象。特点：在多线程环境下可能存在线程安全问题，需要通过加锁或双重检查锁机制来保证线程安全。第一次获取实例时会稍微耗费一些时间，因为需要在运行时创建对象。示例代码：publicclassSingleton
  • JVM对象创建与内存分配机制分析 旺仔爱Java JVM专题jvmjava
    JVM对象创建与内存分配机制分析前言一、对象的创建二、分配内存1）内存划分2）本地线程分配缓冲三、初始化四、设置对象头五、执行方法六、对象内存分配七、对象内存回收可达性分析算法：总结前言最新的Java面试题，技术栈涉及Java基础、集合、多线程、Mysql、分布式、Spring全家桶、MyBatis、Dubbo、缓存、消息队列、Linux…等等，会持续更新。如果对老铁有帮助，帮忙免费点个赞，谢谢你
  • JVM级缓存本地缓存Caffeine 旺仔爱Java JVM专题jvmJVM缓存本地缓存CaffeineGuavaCache
    JVM级缓存本地缓存Caffeine和GuavaCache前言一、创建缓存的代码逻辑二、Caffeine的优化方面淘汰算法W-TinyLFU三、Caffeine的业务使用总结前言最新的Java面试题，技术栈涉及Java基础、集合、多线程、Mysql、分布式、Spring全家桶、MyBatis、Dubbo、缓存、消息队列、Linux…等等，会持续更新。一、创建缓存的代码逻辑Caffeine：publ
  • Python的进程、线程和协程 HelloFif python
    多线程理解在Python中，多线程允许程序同时执行多个任务。他是通过创建线程并将任务分配给不同的线程来实现的，这有助于提高程序的执行效率，特别是在执行多个IO操作的时候，不过由于python的解释器锁（GIL），在执行cpu密集型任务的时候，多线程可能不会带来性能的提升应用场景多线程经常用于IO密集型的任务，比如网络请求，文件读写等，例如在开发一个网络爬虫的时候，可以使用多线程同时下载多个网页，这
  • Spark的数据结构——RDD bluedraam_pp Sparkspark数据结构大数据
    RDD的5个特征下面来说一下RDD这东西，它是ResilientDistributedDatasets的简写。咱们来看看RDD在源码的解释。Alistofpartitions:在大数据领域，大数据都是分割成若干个部分，放到多个服务器上，这样就能做到多线程的处理数据，这对处理大数据量是非常重要的。分区意味着，可以使用多个线程了处理。Afunctionforcomputingeachsplit：作用在
  • 腾讯春招C++面试题大解析：最全面！最详细！2024年必备攻略，99%的开发者已收藏！ 程序员Chino的日记 c++面试
    为了帮助广大C++开发者和腾讯春季招聘的求职者们更好地准备面试，本文汇总并详细解析了一系列精选的C++面试题，这些问题旨在全面考察应聘者在C++基础知识、高级特性、设计模式、内存管理、多线程并发编程、网络编程等方面的能力。通过这些问题的深入探讨，读者不仅能够检验和巩固自己的C++知识储备，还能够了解到腾讯等顶级互联网公司在技术面试中所注重的重点和考查方向。无论是即将参加春季招聘的求职者，还是希望通
  • 架构师之路--JAVA基础和多线程基础个别问题整理 shine_du 架构师之路多线程java队列
    并发和锁（1）synchronized在JDK6做了哪些优化1.适应自旋锁：自旋锁：为了减少线程状态改变带来的消耗不停地执行当前线程2.锁消除：不可能存在共享数据竞争的锁进行消除3.锁粗化：将连续的加锁精简到只加一次锁4.轻量级锁：无竞争条件下通过CAS消除同步互斥5.偏向锁：无竞争条件下消除整个同步互斥，连CAS都不操作。Java并发编程：Lock转载http://www.cnblogs.com
  • C#/.Net 多线程下载m3u8视频 weixin_42199478 c#.net.netcore
    C#/.Net多线程下载m3u8视频下载网络文件方法下载m3u8.HttpGet()是我自己封装的HTTP请求方法下载网络文件方法//////下载网络文件//////文件地址///保存路径publicstaticvoidDownloadFile(thisstringurl,stringsavePath){WebClientwc=newWebClient();//从路径中取得文件名称varname=
  • Java并发操作，多线程 众星揽月 多线程java开发java
    Thread/Runable/Callable：多线程的三个实现方式适用场景：多线程编程优点：Callable的call方法有返回值，Runable/Callable为接口，能多实现缺点：Thread为抽象类，只能单继承Thread.sleep(millis)/Object.wait()/Object.notify()/Object.notifyAll()/Object.join()/Condit
  • Python面试题 生活需要深度 PythonPython面试
    1、python多线程有个全局解释器锁（globalinterpreterlock），这个锁的意思是任一时间只能有一个线程使用解释器，跟单cpu跑多个程序一个意思，大家都是轮着用的，这叫“并发”，不是“并行”。多进程间共享数据，可以使用multiprocessing.Value和multiprocessing.Array。如果你的应用真的对性能有超级严格的要求，比如100us就对你的应用有很大影响
  • 常见锁策略，synchronized内部原理以及CAS 想进大厂的小王 java算法开发语言
    常见的锁策略一些常见的锁策略可以帮助我们在实际开发中更合理的使用锁：乐观锁vs悲观锁：乐观锁：不加锁进行读取，适用于读操作频繁、写操作较少的情况，性能较高。悲观锁：读写都加锁，适用于写操作频繁的情况，保证了数据的一致性，但性能较低。轻量级锁vs重量级锁：轻量级锁：采用CAS操作尝试获取锁，适用于多线程竞争不激烈的情况，性能较高。重量级锁：多线程竞争激烈时，会将后续线程阻塞挂起，性能较低。自旋锁vs
  • 单例模式 rbty
    单例模式单例模式可以分为饿汉式和懒汉式饿汉式会在类装载的时候变完成实例化，如果从未使用过这个实例则会造成内存浪费而懒汉式则是在需要的时候由使用者自行创建实例，这里的问题是如何在多线程环境下保证单例单例模式的实现方式饿汉式（静态常量）注：静态常量位于虚拟机内存的方法区，是线程共享的。publicclassSingleton{privatefinalstaticSingletonINSTANCE=ne
  • Java开发中，spring mvc 的线程怎么调用？ 小麦麦子 springmvc
    今天逛知乎，看到最近很多人都在问spring mvc 的线程http://www.maiziedu.com/course/java/ 的启动问题，觉得挺有意思的，那哥们儿问的也听仔细，下面的回答也很详尽，分享出来，希望遇对遇到类似问题的Java开发程序猿有所帮助。 问题：     在用spring mvc架构的网站上，设一线程在虚拟机启动时运行，线程里有一全局
  • maven依赖范围 bitcarter maven
    1.test 测试的时候才会依赖，编译和打包不依赖，如junit不被打包 2.compile 只有编译和打包时才会依赖 3.provided 编译和测试的时候依赖，打包不依赖，如：tomcat的一些公用jar包 4.runtime 运行时依赖，编译不依赖 5.默认compile 依赖范围compile是支持传递的，test不支持传递 1.传递的意思是项目A，引用
  • Jaxb org.xml.sax.saxparseexception : premature end of file darrenzhu xmlprematureJAXB
    如果在使用JAXB把xml文件unmarshal成vo(XSD自动生成的vo)时碰到如下错误： org.xml.sax.saxparseexception : premature end of file 很有可能时你直接读取文件为inputstream，然后将inputstream作为构建unmarshal需要的source参数。InputSource inputSource = new In
  • CSS Specificity 周凡杨 html权重Specificitycss
      有时候对于页面元素设置了样式，可为什么页面的显示没有匹配上呢？ because specificity CSS 的选择符是有权重的，当不同的选择符的样式设置有冲突时，浏览器会采用权重高的选择符设置的样式。     规则：   HTML标签的权重是1 Class 的权重是10 Id 的权重是100
  • java与servlet g21121 servlet
    servlet 搞java web开发的人一定不会陌生，而且大家还会时常用到它。 下面是java官方网站上对servlet的介绍： java官网对于servlet的解释 写道 Java Servlet Technology Overview Servlets are the Java platform technology of choice for extending and enha
  • eclipse中安装maven插件 510888780 eclipsemaven
    1.首先去官网下载 Maven： http://www.apache.org/dyn/closer.cgi/maven/binaries/apache-maven-3.2.3-bin.tar.gz 下载完成之后将其解压， 我将解压后的文件夹：apache-maven-3.2.3， 并将它放在 D:\tools目录下， 即 maven 最终的路径是：D:\tools\apache-mave
  • jpa@OneToOne关联关系 布衣凌宇 jpa
    Nruser里的pruserid关联到Pruser的主键id，实现对一个表的增删改，另一个表的数据随之增删改。 Nruser实体类 //***************************************************************** @Entity @Table(name="nruser") @DynamicInsert @Dynam
  • 我的spring学习笔记11-Spring中关于声明式事务的配置 aijuans spring事务配置
    这两天学到事务管理这一块，结合到之前的terasoluna框架，觉得书本上讲的还是简单阿。我就把我从书本上学到的再结合实际的项目以及网上看到的一些内容，对声明式事务管理做个整理吧。我看得Spring in Action第二版中只提到了用TransactionProxyFactoryBean和<tx:advice/>,定义注释驱动这三种，我承认后两种的内容很好，很强大。但是实际的项目当中
  • java 动态代理简单实现 antlove javahandlerproxydynamicservice
    dynamicproxy.service.HelloService package dynamicproxy.service; public interface HelloService { public void sayHello(); }   dynamicproxy.service.impl.HelloServiceImpl package dynamicp
  • JDBC连接数据库 百合不是茶 JDBC编程JAVA操作oracle数据库
             如果我们要想连接oracle公司的数据库，就要首先下载oralce公司的驱动程序，将这个驱动程序的jar包导入到我们工程中;   JDBC链接数据库的代码和固定写法;     1,加载oracle数据库的驱动;     &nb
  • 单例模式中的多线程分析 bijian1013 javathread多线程java多线程
    谈到单例模式，我们立马会想到饿汉式和懒汉式加载，所谓饿汉式就是在创建类时就创建好了实例，懒汉式在获取实例时才去创建实例，即延迟加载。 饿汉式： package com.bijian.study; public class Singleton { private Singleton() { } // 注意这是private 只供内部调用 private static
  • javascript读取和修改原型特别需要注意原型的读写不具有对等性 bijian1013 JavaScriptprototype
            对于从原型对象继承而来的成员，其读和写具有内在的不对等性。比如有一个对象A，假设它的原型对象是B，B的原型对象是null。如果我们需要读取A对象的name属性值，那么JS会优先在A中查找，如果找到了name属性那么就返回；如果A中没有name属性，那么就到原型B中查找name，如果找到了就返回；如果原型B中也没有
  • 【持久化框架MyBatis3六】MyBatis3集成第三方DataSource bit1129 dataSource
    MyBatis内置了数据源的支持，如：   <environments default="development"> <environment id="development"> <transactionManager type="JDBC" /> <data
  • 我程序中用到的urldecode和base64decode,MD5 bitcarter cMD5base64decodeurldecode
    这里是base64decode和urldecode，Md5在附件中。因为我是在后台所以需要解码： string Base64Decode(const char* Data,int DataByte,int& OutByte) { //解码表 const char DecodeTable[] = { 0, 0, 0, 0, 0, 0
  • 腾讯资深运维专家周小军：QQ与微信架构的惊天秘密 ronin47
    社交领域一直是互联网创业的大热门，从PC到移动端，从OICQ、MSN到QQ。到了移动互联网时代，社交领域应用开始彻底爆发，直奔黄金期。腾讯在过去几年里，社交平台更是火到爆，QQ和微信坐拥几亿的粉丝，QQ空间和朋友圈各种刷屏，写心得，晒照片，秀视频，那么谁来为企鹅保驾护航呢？支撑QQ和微信海量数据背后的架构又有哪些惊天内幕呢？本期大讲堂的内容来自今年2月份ChinaUnix对腾讯社交网络运营服务中心
  • java-69-旋转数组的最小元素。把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素 bylijinnan java
    public class MinOfShiftedArray { /** * Q69 旋转数组的最小元素 * 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。 * 例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。 */ publ
  • 看博客，应该是有方向的 Cb123456 反省看博客
    看博客，应该是有方向的:  我现在就复习以前的，在补补以前不会的，现在还不会的，同时完善完善项目，也看看别人的博客.  我刚突然想到的:  1.应该看计算机组成原理，数据结构，一些算法，还有关于android,java的。  2.对于我，也快大四了，看一些职业规划的，以及一些学习的经验，看看别人的工作总结的.    为什么要写
  • [开源与商业]做开源项目的人生活上一定要朴素,尽量减少对官方和商业体系的依赖 comsci 开源项目
         为什么这样说呢？  因为科学和技术的发展有时候需要一个平缓和长期的积累过程，但是行政和商业体系本身充满各种不稳定性和不确定性，如果你希望长期从事某个科研项目，但是却又必须依赖于某种行政和商业体系，那其中的过程必定充满各种风险。。。       所以，为避免这种不确定性风险，我
  • 一个 sql优化 （[精华] 一个查询优化的分析调整全过程！很值得一看 ） cwqcwqmax9 sql
    见   http://www.itpub.net/forum.php?mod=viewthread&tid=239011 Web翻页优化实例 提交时间: 2004-6-18 15:37:49      回复    发消息  环境： Linux ve
  • Hibernat and Ibatis dashuaifu Hibernateibatis
    Hibernate  VS  iBATIS 简介 Hibernate 是当前最流行的O/R mapping框架，当前版本是3.05。它出身于sf.net，现在已经成为Jboss的一部分了 iBATIS 是另外一种优秀的O/R mapping框架，当前版本是2.0。目前属于apache的一个子项目了。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mappi
  • 备份MYSQL脚本 dcj3sjt126com mysql
    #!/bin/sh # this shell to backup mysql #[email protected] (QQ:1413161683 DuChengJiu) _dbDir=/var/lib/mysql/ _today=`date +%w` _bakDir=/usr/backup/$_today [ ! -d $_bakDir ] && mkdir -p
  • iOS第三方开源库的吐槽和备忘 dcj3sjt126com ios
    转自 ibireme的博客   做iOS开发总会接触到一些第三方库，这里整理一下，做一些吐槽。   目前比较活跃的社区仍旧是Github，除此以外也有一些不错的库散落在Google Code、SourceForge等地方。由于Github社区太过主流，这里主要介绍一下Github里面流行的iOS库。   首先整理了一份 Github上排名靠
  • html wlwmanifest.xml eoems htmlxml
    所谓优化wp_head()就是把从wp_head中移除不需要元素，同时也可以加快速度。 步骤： 加入到function.php remove_action('wp_head', 'wp_generator'); //wp-generator移除wordpress的版本号，本身blog的版本号没什么意义，但是如果让恶意玩家看到，可能会用官网公布的漏洞攻击blog remov
  • 浅谈Java定时器发展 hacksin java并发timer定时器
    java在jdk1.3中推出了定时器类Timer,而后在jdk1.5后由Dou Lea从新开发出了支持多线程的ScheduleThreadPoolExecutor，从后者的表现来看，可以考虑完全替代Timer了。 Timer与ScheduleThreadPoolExecutor对比： 1.    Timer始于jdk1.3,其原理是利用一个TimerTask数组当作队列
  • 移动端页面侧边导航滑入效果 ini jqueryWebhtml5cssjavascirpt
    效果体验：http://hovertree.com/texiao/mobile/2.htm可以使用移动设备浏览器查看效果。效果使用到jquery-2.1.4.min.js，该版本的jQuery库是用于支持HTML5的浏览器上，不再兼容IE8以前的浏览器，现在移动端浏览器一般都支持HTML5，所以使用该jQuery没问题。HTML文件代码： <!DOCTYPE html> <h
  • AspectJ+Javasist记录日志 kane_xie aspectjjavasist
    在项目中碰到这样一个需求，对一个服务类的每一个方法，在方法开始和结束的时候分别记录一条日志，内容包括方法名，参数名+参数值以及方法执行的时间。   @Override public String get(String key) { // long start = System.currentTimeMillis(); // System.out.println("Be
  • redis学习笔记 MJC410621 redisNoSQL
    1)nosql数据库主要由以下特点：非关系型的、分布式的、开源的、水平可扩展的。 1，处理超大量的数据 2，运行在便宜的PC服务器集群上， 3，击碎了性能瓶颈。 1)对数据高并发读写。 2)对海量数据的高效率存储和访问。 3)对数据的高扩展性和高可用性。 redis支持的类型： Sring 类型 set name lijie get name lijie set na
  • 使用redis实现分布式锁 qifeifei
    在多节点的系统中，如何实现分布式锁机制，其中用redis来实现是很好的方法之一，我们先来看一下jedis包中，有个类名BinaryJedis,它有个方法如下：   public Long setnx(final byte[] key, final byte[] value) { checkIsInMulti(); client.setnx(key, value); ret
  • BI并非万能，中层业务管理报表要另辟蹊径 张老师的菜 大数据BI商业智能信息化
           BI是商业智能的缩写，是可以帮助企业做出明智的业务经营决策的工具，其数据来源于各个业务系统，如ERP、CRM、SCM、进销存、HER、OA等。        BI系统不同于传统的管理信息系统，他号称是一个整体应用的解决方案，是融入管理思想的强大系统：有着系统整体的设计思想，支持对所有
  • 安装rvm后出现rvm not a function 或者ruby -v后提示没安装ruby的问题 wudixiaotie function
    1.在~/.bashrc最后加入 [[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"  2.重新启动terminal输入：   rvm use ruby-2.2.1 --default  把当前安装的ruby版本设为默
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他