精华内容
下载资源
问答
  • Cache是基于python的线程缓存插件,类似于redis的key,value形式的线程化数据存储功能,使用方便,相对于不是很复杂的缓存任务,Cache完全可以满足需求 使用方法: Cache().setex(k, v, timeout) #设置缓存及过期时间 ...

    Cache是基于python的线程缓存插件,类似于redis的key,value形式的线程化数据存储功能,使用方便,相对于不是很复杂的缓存任务,Cache完全可以满足需求

    使用方法:

    Cache().setex(k, v, timeout)  #设置缓存及过期时间
    Cache().get(k)  #获取缓存
    项目地址: github.com
    展开全文
  • 多线程接收数据并缓存到BlockingQueue,然后多线程消费缓存数据 请大家看看, 有没有什么问题, 请指出,谢谢 。package com.ygd.learn.threadTest.lock1.dtc; import java.text.MessageFormat; import java.util....

    多线程接收数据并缓存到BlockingQueue,然后多线程消费缓存数据

    这个例子如果稍微改造,可以实现按照数据类型区分缓存

    请大家看看, 有没有什么问题, 请指出,谢谢 。

    package com.ygd.learn.threadTest.lock1.dtc;
    
    import java.text.MessageFormat;
    import java.util.concurrent.*;
    
    /**
     * Description
     * 模拟一个接口多线程接收数据,然后缓存到blockingQueue中, 然后多线程消费缓存在blockingQueue中的数据
     * 其中每个线程处理一个缓存的blockingQueue的数据, 也就是blockingQuere的数量和线程的接收/消费的线程数相同
     * Created by ygd on 2017/9/1.
     */
    public class DtcTest {
        ConcurrentMap<Integer,ArrayBlockingQueue<String>> concurrentMap = new ConcurrentHashMap<Integer,ArrayBlockingQueue<String>>();// 全局的。用来存放缓存数据的blockingQueue
        private final int blockQueueCount = 20 ;// blockQueue的数量,设计的是一个线程一个blockQueue ,来存放接收的数据
        private final int blockQuerySize = 200 ;// 每个blockQueue的大小
    
        public static void main(String[] args) {
    
            DtcTest dtcTest = new DtcTest();
            ReceiveDataCache receiveDataCache = dtcTest.new ReceiveDataCache();
            receiveDataCache.execute();
    
            SaveData saveData = dtcTest.new SaveData();
            saveData.execute();
        }
    
        /**
         * 消费blockingQueue中的数据
         */
        class SaveData{
    
    
            public void execute(){
                ExecutorService executorService = Executors.newFixedThreadPool(blockQueueCount);
                for(int i = 0 ;i <blockQueueCount ; i++){
                    ExecuteClass executeClass = new ExecuteClass();
                    executeClass.setBlockQueueKey(i);
                    executorService.submit(executeClass);
                }
            }
    
            class ExecuteClass implements Callable<String>{
                private int blockQueueKey ;
                @Override
                public String call() throws Exception {
                    ArrayBlockingQueue<String>  arrayBlockingQueue = concurrentMap.get(this.getBlockQueueKey());
                    for(;;){// 无限循环从blockQueue中取数据
                        try {
                            String data = arrayBlockingQueue.poll(1,TimeUnit.SECONDS);
                            if(null==data){
                                System.out.println(MessageFormat.format("currentThread {0} had no data ",Thread.currentThread().getName()));
                            }else{
    //                            System.out.println(data+"-----");
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
    
                public int getBlockQueueKey() {
                    return blockQueueKey;
                }
    
                public void setBlockQueueKey(int blockQueueKey) {
                    this.blockQueueKey = blockQueueKey;
                }
            }
        }
    
    
        /**
         * 接收数据的cache类
         */
        class ReceiveDataCache{
    
            public ReceiveDataCache(){
                this.init();
            }
    
            private void init(){
                /**
                 * 1、创建一个concurrentMap来存放系统中的所有BlockingQueue,系统中一共有200个BlockQuere
                 * 2、每个BlockQueue的长度是200
                 * 以上两个数据结构就是接收数据的缓存结构
                 */
                for(int i = 0 ;i <blockQueueCount ; i++){
                    concurrentMap.put(i,new ArrayBlockingQueue<String>(blockQuerySize));
                }
            }
    
            public void execute(){
                ExecutorService executorService = Executors.newFixedThreadPool(blockQueueCount);
                for(int i = 0  ;i <blockQueueCount ; i++){
                    ExecuteClass executeClass = new ExecuteClass();
                    executeClass.setBlockQueueKey(i);
                    executorService.execute(executeClass);
                }
            }
    
    
            class ExecuteClass implements Runnable{
                private int blockQueueKey ;
                @Override
                public void run() {
                    ArrayBlockingQueue<String> arrayBlockingQueue = concurrentMap.get(this.getBlockQueueKey());
                    int size = 0 ;
                    for(;;){// 无限循环向blockQueue中放数据
                        try {
                            size ++ ;
                            String str = "block-"+this.getBlockQueueKey()+"thread-"+Thread.currentThread().getName()+"-size-"+size;
                            Thread.sleep(1000);
                            boolean result = arrayBlockingQueue.offer(str);
                            if(!result){
                                System.out.println(MessageFormat.format("currenThread {0} offer blockQueue {1} had full",Thread.currentThread().getName(),this.getBlockQueueKey()));
    
                            }else{
    //                            System.out.println(str);
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
    
                public int getBlockQueueKey() {
                    return blockQueueKey;
                }
    
                public void setBlockQueueKey(int blockQueueKey) {
                    this.blockQueueKey = blockQueueKey;
                }
            }
    
    
        }
    }


    
    



    展开全文
  • 多线程的队列循环缓存

    千次阅读 2016-06-07 11:41:22
    程序开发中经常遇到一种情况:一个线程收数据(例如socket->recv),一个线程处理数据。 这种情况下,我通常的处理方式是一个公共的buff、一个锁,接收线程收到数据后,加锁拷贝内存记录偏移。另一个线程判断偏移大于...

    应用场景

    程序开发中经常遇到一种情况:一个线程收数据(例如socket->recv),一个线程处理数据。

    这种情况下,我通常的处理方式是一个公共的buff、一个锁,接收线程收到数据后,加锁拷贝内存记录偏移。另一个线程判断偏移大于零时呢,加锁,内存拷贝出来,然后处理。

    这时就设计,需要加锁,如果高速数据接收(如万兆网),可能导致接收不及时丢包。

    进而需要设计一种无锁的缓存

    无锁缓存

    思路

    1.一个接收数据线程,一个处理数据线程

    2.定义100个10M的缓存,每个缓存有一个枚举值状态,包括:空、在写入、在读取

    3.这样的话,收数据线程,跟这个100个缓存的状态往里面写​,数据处理线程,根据100个缓存的状态处理

    4.这样达到没有锁的效果​

    具体的缓存个数,缓存大小可以根据实际需要定义。

    缓存队列使用的话,应该顺序使用,到队列头部,然后从头开始,若缓存状态为在读入,那么说明处理数据太慢,数据处理不过来,应该有异常上报机制。


    代码 

    strcut{
    enum bufState{empty,writeing,reading;};
    buffState  st;
    char * buff;
    int offset;
    } buff;
    
    buff   buffQue[100];
    
    createBuffQue();
    
    





    展开全文
  • 线程缓存的探索

    千次阅读 2015-10-05 15:09:34
    线程通信有两种方式:共享内存与消息传递。 共享内存即多个线程共享程序的公共变量,通过变量状态的读写来进行隐式共享;消息传递则是线程之间...而在Java中,采用的是共享内存来进行线程间通信(多线程共享变量方式 )

    线程通信有两种方式:共享内存与消息传递。
    共享内存即多个线程共享程序的公共变量,通过变量状态的读写来进行隐式共享;消息传递则是线程之间没有公共变量,而是通过消息传递来进行显示的通信。而在Java中,采用的是共享内存来进行线程间通信(多线程共享变量方式 )

    Java中线程间通信由Java内存模型(JMM)来控制,JMM决定了共享变量的写入何时对另一个线程可见。JMM的抽象示意图如下:
    这里写图片描述

    可以看到,每个线程都是有一个共享变量的副本,每次访问都是先访问共享变量副本,如果没有做出同步操作,那么可能会导致一些内存一致性问题。下面做一个实验。
    实验性质:验证性实验
    实验目的:验证内存一致性问题真实存在。
    实验步骤:1. 创建一个读线程,对共享变量进行读取操作,并打印读取的结果;2.创建一个写线程,对共享变量进行修改,并打印修改后的结果;3.观察打印结果

    共享变量:

    public class Model {
    	public int i;
    }
    
    

    读线程:

    public class ReadThread extends Thread {
    	Model model;
    
    	public ReadThread(Model model) {
    		this.model = model;
    	}
    	@Override
    	public void run() {
    		while (true) {
    			System.out.println(this.getName() + ":"
    					+ System.currentTimeMillis() + ":" + model.i);
    		}
    	}
    }
    

    写线程:

    public class WriteThread extends Thread {
    	Model model;
    
    	public WriteThread(Model model) {
    		this.model = model;
    	}
    
    	@Override
    	public void run() {
    		while (true) {
    			model.i++;
    			System.out.println(this.getName() + ":"
    					+ System.currentTimeMillis() + ":" + model.i);
    		}
    	}
    }
    

    主函数:

    public class Main {
    	public static void main(String[] args) throws IOException {
    		File file = new File("E://log.txt");
    		if(!file.exists()){
    			file.createNewFile();
    		}
    		System.setOut(new PrintStream(file));
    		
    		
    		Model model = new Model();
    		model.i = 1;
    
    		ReadThread readThead = new ReadThread(model);
    		readThead.setName("readThread");
    
    		WriteThread writeThread = new WriteThread(model);
    		writeThread.setName("writeThread");
    
    		readThead.start();
    		writeThread.start();
    	}
    }
    

    测试结果(节选有问题片段):

    readThread:1444028570784:2
    writeThread:1444028570784:2
    readThread:1444028570784:2
    writeThread:1444028570784:3
    writeThread:1444028570784:4
    readThread:1444028570784:3
    writeThread:1444028570784:5
    readThread:1444028570784:5
    writeThread:1444028570784:6
    readThread:1444028570784:6

    注意第七行位置,writeThread已经读到i的值变为4,而readThread读取到的值仍为3.

    一起学习交流呀
    在这里插入图片描述

    展开全文
  • 多线程下获取缓存问题

    千次阅读 2014-06-20 17:32:27
    多线程下获取缓存问题 多线程下使用HttpContext.Current.Cache.Get(key)获取缓存时HttpContext.Current为null,解决办法如下: HttpRuntime.Cache.Get(key); 从MSDN上的解释可以看出,HttpRuntime.Cache是...
  • mybatis 多线程环境下缓存问题

    千次阅读 2013-10-17 13:23:37
    使用mybatis的都应该知道,mybatis是对select语句进行缓存的额,同一个select在一次sqlSession未被关闭之前是不会执行多次的(前提是对应的数据未被修改过,确切的说是未被...但是如果你的应用处于多线程并发环境下...
  • Java的多线程并发出现缓存一致性问题  (如有错误,请不吝赐教)  首先我们得知道什么是缓存,并明白什么是缓存缓存是介于物理存储与CPU处理之间的一段内存空间,主要用于存储从物理存储读出、或者要写入的...
  • 多线程---缓存系统

    千次阅读 2012-02-13 21:50:35
    首先解释下缓存系统:  在程序运行过程中,有些数据我们不会经常修改,例如数据库中性别字段,但是我们却经常使用,如果每次都从数据库中获取,那么将会降低程序性能。那么我们可以在内存中分配一个区域专门存放...
  • 万字图解Java多线程

    万次阅读 多人点赞 2020-09-06 14:45:07
    java多线程我个人觉得是javaSe中最难的一部分,我以前也是感觉学会了,但是真正有多线程的需求却不知道怎么下手,实际上还是对多线程这块知识了解不深刻,不知道多线程api的应用场景,不知道多线程的运行流程等等,...
  • 在前两篇博客中介绍了单线程化线程池... 在JAVA文档中是这样介绍可回收缓存线程池的:创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们。对于执行很短期异步...
  • 其中涉及到读写问题:当线程执行读操作时(都加读锁),如果有数据返回;如果没有数据时,则让第一个读的线程,进行获取数据,然后进行写操作,这时需要第一个线程先释放掉读锁然后加写锁。第一个写完后,在家读...
  • Java 多线程:彻底搞懂线程池

    万次阅读 多人点赞 2019-07-09 19:27:00
    熟悉Java多线程编程的同学都知道,当我们线程创建过多时,容易引发内存溢出,因此我们就有必要使用线程池的技术了。 目录 1 线程池的优势 2 线程池的使用 3 线程池的工作原理 4 线程池的参数 4.1 任务队列...
  • MySQL内存使用说明(全局缓存+线程缓存)  首先我们来看一个公式,MySQL中内存分为全局内存和线程内存两大部分(其实并不全部,只是影响比较大的 部分): per_thread_buffers=(read_buffer_size+read_...
  • Java的多线程机制:缓存一致性和CAS

    千次阅读 2015-10-18 21:21:57
    一、总线锁定和缓存一致性 这是两个操作系统层面的概念。随着多核时代的到来,并发操作已经成了很正常的现象,操作系统必须要有一些机制和原语,以保证某些基本操作的原子性,比如处理器需要保证读一个字节或写一...
  • **项目中,经常碰见需要在项目初始化时完成从mysql的数据写入到缓存如redis中的操作,例如ssm架构项目中,需要某个类实现一个initializeBean的接口,在这个类里面完成初始化的操作,将mysql的数据写到redis或其他...
  • 一、总线锁定和缓存一致性基本概念这是两个操作系统层面的概念。随着多核时代的到来,并发操作已经成了很正常的现象,操作系统必须要有一些机制和原语,以保证某些基本操作的原子性,比如处理器需要保证读一个字节或...
  • 网上有很多介绍说StringBuilder的复用写法,其中“为了避免并发访问,可以在ThreadLocal中使用StringBuilderHolder” ``` public class StringBuilderUtil { ...还是我的理解有误,并发和多线程不一样??
  • 高并发多线程读写锁的应用
  • 无论是单核处理器还是多核处理器,当线程数量增多时,线程使用同一个核。还是这个例子,假设A线程和B线程共享主存数据a变量,A、B线程读入到CPU缓存后,到底是一个缓存呢?还是各自线程看到的缓存是不一样的?
  • 多线程22多图下载2_第二种实现方式三级缓存 一分析第一种方式的不足 二三级缓存 1 什么是三级缓存 2 三级缓存的工作原理 三多图下载三级缓存分析 四代码 五图示 多线程22——多图下载2_第二种实现方式(三级缓存)一、...
  • Java多线程

    万次阅读 多人点赞 2021-06-11 16:28:49
    Java多线程Java多线程线程的创建线程常见方法线程的状态线程的优先级守护线程线程组Java线程池线程池的创建线程池的参数线程池的使用线程不安全问题Java中的锁synchronized同步方法synchronized同步语句块...
  • ![图片说明](https://img-ask.csdn.net/upload/201612/13/1481623032_996863.jpg) 这是一个map 里面大概有10万数据,在这里我想改成多线程遍历map插入缓存数据库。 不知道怎么写。求大神赐教。
  • 虽然遵循 as-if-serial语义,但是它是仅在单个CPU自己执行的情况下保证结果正确,多核多线程,指令逻辑无法分辨因果关联,可能出现乱序执行,导致程序结果出现错误。 内存屏障解决以上问题 写内存屏障(Store ...
  • 如果线程缓存现在超过了某个预定的大小(默认为2MB),我们便运行垃圾收集器将未使用的对象从线程缓存中移入中央自由列表。 如果该对象是大对象的话,跨度会告诉我们该对象覆盖的页面的范围。假设该范围是 [p,q] ...
  • 线程缓存ThreadLocalCache

    千次阅读 2019-03-21 10:11:24
    线程缓存ThreadLocalCache 源起 很时候一条操作链路上需要获取很重复的基础信息,比如用户的信息,可能在AO层也有,Service 层也有,这样造成的问题是每次都需要发起一次调用(数据库 or RPC),这样造成的...
  • 多线程

    万次阅读 2018-02-28 16:55:11
    Java多线程实现方式主要有四种:继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。 其中前两种方式线程...
  • 缓存过期之后,如果线程同时请求对某个数据的访问,会同时去到数据库,导致数据库瞬间负荷增高。Spring4.3为@Cacheable注解提供了一个新的参数“sync”(boolean类型,缺省为false),当设置它为true时,只有一...
  • 多线程面试题(值得收藏)

    万次阅读 多人点赞 2019-08-16 09:41:18
    史上最强多线程面试47题(含答案),建议收藏 金九银十快到了,即将进入找工作的高峰期,最新整理的最全多线程并发面试47题和答案总结,希望对想进BAT的同学有帮助,由于篇幅较长,建议收藏后细看~ 1、并发编程三要素?...
  • 技术实现上有三个重点:异步化(一般使用mq)、缓存(一般使用redis)、多线程 一个功能并发量上大的提升,是需要业务和技术上共同去努力实现的。重点在于业务上的解耦,技术上的异步化。 假设一个核心系统分为三个...
  • 有两种机制:总线锁定和缓存一致性。下面,尚学堂陈老师简单为大家分享总线锁定和缓存一致性的问题。 我们知道,CPU和物理内存之间的通信速度远慢于CPU的处理速度,所以CPU有自己的内部缓存,根据一些规则将内存中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 516,156
精华内容 206,462
关键字:

多线程缓存