双11狂欢大促

盲盒赢 定制羽绒服

开启惊喜盲盒，抽取你的专属好礼

— 惊喜奖品抢先看 —

超级年卡50元券

周边70元券

手机支架

一拖三数据线

雨伞

运动毛巾

电动牙刷

VIP月卡

机械键盘

定制羽绒服

超级年卡50元券

周边70元券

手机支架

一拖三数据线

雨伞

运动毛巾

电动牙刷

VIP月卡

机械键盘

定制羽绒服

统计页面访问量，需要存储到数据库，但是对于并发和大批量的访问数据库，有什么优化的办法吗

2015-05-09 12:02:23 404 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

yekeyishuo 墨衍会员 · AI 创作全网分发关注 + 加入社区

零成本实现飞牛 OS 内网穿透：CloudFlare 隧道搭建全攻略一、引言：突破内网限制的最优解当你的内网环境中部署了飞牛 OS 系统（无论是老旧电脑还是 NAS 设备），想要实现公网访问时，传统方案往往面临两大痛点：公网 IP 申请困难且成本高DDNS 动态解析配置复杂专业内网穿透工具存在付费门槛今天为大家带来零成本解决方案：通过免费域名搭配 CloudFlare 隧道技术，无需公网 IP 即可轻松实现飞牛 OS 服务的公网访问。全程操作可视化，新手也能快速上手！二、前期准备：必备工具清单（1）域名准备。阅读详情

统计页面访问量，需要存储到数据库，但是对于并发和大批量的访问数据库，有什么优化的办法吗？

每次访问都去连接数据库并自增1，这样对于数据库的压力还是挺大的，请问，一般网站是怎么做的呢？

...全文

[代码开源]基于DistFlow的IEEE33和IEEE69节点最优潮流模型(OPF)实现与性能分析本文详细介绍了基于DistFlow的IEEE33和IEEE69节点最优潮流模型(OPF)的实现与性能分析。通过代码开源，展示了如何从零搭建电力系统优化模型，解决配电网中的发电成本最小化问题。文章涵盖数据准备、模型实现细节、性能优化建议及常见问题解答，为电力系统研究者提供实用参考。阅读详情

yekeyishuo

Web 开发 81,108 成员 341,720 内容

+ 关注 + 加入社区

切换为时间正序

Chengyajie521 2015-05-09

打赏
举报

其实这些东西可以通过分析阿帕奇或者nginx的日志来拿……每天定时跑日志就好了

疯狂熊猫人 2015-05-09

打赏
举报

给你一个我写的处理类似场景的批量操作工具类吧，非常简单

public final class BatchHandleWrapper<E> {

	private LinkedBlockingQueue<E> queue;
	private boolean running = true;
	private ExecutorService exec;
	private int batchSize = 100;
	private int queueSize = Integer.MAX_VALUE;
	private int timeout = 5000;
	private int taskCount = 1;
	private BatchHandler<E> batchHandler;
	private EnqueueHandler<E> enqueueHandler;
	
	public static <T> BatchHandleWrapper<T> batchHandler(BatchHandler<T> batchHandler){
		return new BatchHandleWrapper<>(batchHandler);
	}
	
	public BatchHandleWrapper<E> batchSize(int size){
		if(size>0){
			this.batchSize = size;
		}
		return this;
	}
	
	public BatchHandleWrapper<E> queueSize(int size){
		if(size>0){
			this.queueSize = size;
		}
		return this;
	}
	
	public BatchHandleWrapper<E> timeout(int timeout,TimeUnit unit){
		if(timeout>0){
			this.timeout = (int)unit.toMillis(timeout);
		}
		return this;
	}
	
	public BatchHandleWrapper<E> taskCount(int count){
		if(count>0){
			this.taskCount = count;
		}
		return this;
	}
	
	public BatchHandleWrapper<E> enqueueHandler(EnqueueHandler<E> enqueueHandler){
		this.enqueueHandler = enqueueHandler;
		return this;
	}
	
	public BatchHandleWrapper<E> start(){
		check();
		queue = new LinkedBlockingQueue<>(queueSize);
		exec = Executors.newFixedThreadPool(taskCount);
		BatchTask task = new BatchTask();
		for(int i=0;i<taskCount;i++){
			exec.execute(task);
		}
		return this;
	}
	
	private void check(){
		if(batchHandler==null){
			throw new RuntimeException("BatchHandler不能为空");
		}
	}
	
	private BatchHandleWrapper(BatchHandler<E> batchHandler){
		this.batchHandler = batchHandler;
		check();
	}
	
	/**
	 * 队列大小为{@link Integer#MIN_VALUE}的批量操作包装器
	 * @param batchHandler 批量处理器
	 * @param batchSize 批量操作上限
	 * @param timeoutMs 超时时间(单位：毫秒)
	 * @param taskCount 处理线程数量
	 */
	public BatchHandleWrapper(BatchHandler<E> batchHandler,int batchSize,int timeoutMs,int taskCount){
		this(batchHandler, Integer.MAX_VALUE, batchSize, timeoutMs, taskCount);
	}
	
	/**
	 * 具有指定队列大小的批量操作包装器
	 * @param batchHandler 批量处理器
	 * @param queueSize 队列大小
	 * @param batchSize 批量操作大小
	 * @param timeoutMs 取出元素超时时间(单位：毫秒)
	 * @param taskCount 处理线程数量
	 */
	public BatchHandleWrapper(BatchHandler<E> batchHandler,int queueSize,int batchSize,int timeoutMs,int taskCount){
		this(batchHandler, queueSize, batchSize, timeoutMs, taskCount, null);
	}
	
	/**
	 * 具有指定队列大小和入队失败处理器的批量操作包装器
	 * @param batchHandler 批量处理器
	 * @param queueSize 队列大小
	 * @param batchSize 批量操作大小
	 * @param timeoutMs 超时时间(单位：毫秒)
	 * @param taskCount 处理线程数量
	 * @param enqueueHandler 入队处理器
	 */
	public BatchHandleWrapper(BatchHandler<E> batchHandler,int queueSize,int batchSize,int timeoutMs,int taskCount,EnqueueHandler<E> enqueueHandler){
		if(batchHandler==null||batchSize<1||timeoutMs<0||taskCount<0){
			throw new RuntimeException("参数错误：BatchHandler不能为null，batchSize必须大于0，timeout必须大于0，taskCount必须大于0");
		}
		this.queue = new LinkedBlockingQueue<>(queueSize);
		this.batchSize = batchSize;
		this.timeout = timeoutMs;
		this.batchHandler = batchHandler;
		this.enqueueHandler = enqueueHandler;
		exec = Executors.newFixedThreadPool(taskCount);
		BatchTask task = new BatchTask();
		for(int i=0;i<taskCount;i++){
			exec.execute(task);
		}
	}
	
	public void add(E data){
		try {
			if(enqueueHandler!=null){
				enqueueHandler.handle(queue, data);
			}else{
				queue.put(data);
			}
		} catch (Exception e) {
			//TODO
		}
	}
	
	public void add(E data,int timeoutMs){
		try {
			if(enqueueHandler!=null){
				enqueueHandler.handle(queue, data);
			}else{
				if(!queue.offer(data, timeoutMs, TimeUnit.MILLISECONDS)){
					//TODO
				}
			}
		} catch (Exception e) {
			//TODO
		}
	}
	
	public void stop(){
		running = false;
		exec.shutdownNow();
	}
	
	/**
	 * @author lzy
	 * 批量处理器
	 */
	public static interface BatchHandler<E>{
		/**
		 * 批量方法
		 * @param list 待处理的数据列表
		 * @param task 负责处理数据的线程
		 */
		void handle(List<E> list,Runnable task);
	}
	
	/**
	 * @author lzy
	 * 数据入队处理器
	 */
	public static interface EnqueueHandler<E>{
		/**
		 * 处理方法
		 * @param queue 保存数据的队列
		 * @param obj 待保存数据
		 * @param e 异常
		 */
		void handle(BlockingQueue<E> queue,E obj);
	}
	
	/**
	 * @author lzy
	 * 批量处理任务
	 */
	private class BatchTask implements Runnable{
		
		@Override
		public void run() {
			ArrayList<E> list = new ArrayList<>(batchSize);
			while (running&&!Thread.interrupted()) {
				try {
					E data = queue.poll(timeout, TimeUnit.MILLISECONDS);
					if(data==null){
						batch(list);
					}else{
						list.add(data);
						if(list.size()==batchSize){
							batch(list);
						}
					}
				} catch (Exception e) {
					//TODO
				}
			}
			//停止处理后，批量处理内存中存在的数据
			while(queue.size()>0){
				E data = queue.poll();
				if(data!=null){
					list.add(data);
					if(list.size()==batchSize){
						batch(list);
					}
				}
			}
			batch(list);
		}
		
		private void batch(ArrayList<E> list){
			if(list.size()>0) {
				try {
					batchHandler.handle(list, this);
				} finally {
					//处理数据后，不管成功与否，均清空当前数据
					list.clear();
				}
			}
		}
	}
	
	public static void main(String[] args) {
		BatchHandler<Object> batchHandler = new BatchHandler<Object>() {
			@Override
			public void handle(List<Object> list,Runnable task) {
				System.out.println(list);
			}
		};
		EnqueueHandler<Object> enqueueHandler = new EnqueueHandler<Object>() {
			@Override
			public void handle(BlockingQueue<Object> queue, Object obj) {
				queue.offer(obj);
			}
		};
		final BatchHandleWrapper<Object> bhw = BatchHandleWrapper.batchHandler(batchHandler)
				.batchSize(10)
				.timeout(5, TimeUnit.SECONDS)
				.taskCount(1)
				.enqueueHandler(enqueueHandler)
				.start();
		
		Thread t = new Thread(){
			public void run() {
				for(int i=1;i<=150;i++){
					bhw.add("第"+i,50);
				}
				System.err.println("我放完了");
				bhw.stop();
			};
		};
		t.start();
	}
}

sunaer 2015-05-09

打赏
举报

先把写到cache里, 然后定时任务把每隔一段时间(比如:30分)这个值写到库里

✦双11狂欢大促✦

统计页面访问量，需要存储到数据库，但是对于并发和大批量的访问数据库，有什么优化的办法吗

相关推荐

双11狂欢大促