luxiangxing
luxiangxing

多线程往Oracle数据库里插入数据的优化

昨 天做了一个东西，要实现解析txt文件，然后入库的功能。开始试验了一下单线程插入，速度实在太慢了，半个小时才插入了2W多条数据，后来改用Java的 线程池启用了30个线程，并发的执行，插入100W条数据用了一个多小时。后来又对业务层的事务做了一些调整，每1000条insert之后才提交一次， 一共开了20个线程，最后100W条数据入库一共用了14分钟不到，平均一分钟7.1W条左右。 代码如下：
  1. /**
  2. * 分析Apache日志的定时任务.每天运行数次.
  3. *
  4. * @author Along
  5. *
  6. * @version $Revision$
  7. *
  8. * @since 2009-2-9
  9. */
  10. public class ApacheLogAnalysisTask {
  11.         /**
  12.          * Logger for this class
  13.          */
  14.         private static final Log logger = LogFactory.getLog(ApacheLogAnalysisTask.class);
  15.        
  16.         //总线程数
  17.         private static final int THREAD_COUNT = 20;
  18.        
  19.         //每个线程插入的日志数
  20.         private static final long LOG_COUNT_PER_THREAD = 1000;
  21.        
  22.         //日志文件的位置
  23.         private static final String LOG_FILE = Property.LOG_FILE_PATH + "formatLog.txt";
  24.        
  25.         private IObjectActionDetailService objectActionDetailService;
  26.        

  28.         public void setObjectActionDetailService(IObjectActionDetailService objectActionDetailService) {
  29.                 this.objectActionDetailService = objectActionDetailService;
  30.         }

  32.         public void execute() {
  33.                 this.multiAnalysisLog();
  34.         }
  35.        
  36.         private void multiAnalysisLog() {
  37.                 ExecutorService exePool = Executors.newFixedThreadPool(THREAD_COUNT);
  38.                
  39.                 FileReader fr = null;
  40.                 BufferedReader br = null;
  41.                 long beginLine = 1;
  42.                 long endLine = 0;
  43.                 String logFileBack = Property.LOG_FILE_PATH + "/formatLog_" + DateUtil.getSystemCurrentDate() + "_" + System.currentTimeMillis() + ".txt";
  44.                
  45.                 try {
  46.                         //文件拷贝出来一个新的,并将原先的删除.
  47.                         FileUtil.copyfile(LOG_FILE, logFileBack, true);
  48.                         FileUtil.deleteFile(LOG_FILE);
  49.                         System.out.println(logFileBack);
  50.                        
  51.                         fr = new FileReader(logFileBack);
  52.                         br = new BufferedReader(fr);
  53.                        
  54.                         while ((br.readLine()) != null){
  55.                                 endLine++;
  56.                                
  57.                                 //每个线程分配固定的行数
  58.                                 if((endLine - beginLine + 1) == LOG_COUNT_PER_THREAD) {
  59.                                         exePool.execute(new AnalysisLogTask(logFileBack, beginLine, endLine));
  60.                                         beginLine = endLine + 1;
  61.                                 }
  62.                         }
  63.                        
  64.                         //最后一个线程
  65.                         if (endLine > beginLine) {
  66.                                 exePool.execute(new AnalysisLogTask(logFileBack, beginLine, endLine));
  67.                         }

  69.                 } catch (FileNotFoundException e) {
  70.                         e.printStackTrace();
  71.                 } catch (IOException e) {
  72.                         e.printStackTrace();
  73.                 } finally {
  74.                         if (br != null) {
  75.                                 try {
  76.                                         br.close();
  77.                                         br = null;
  78.                                 } catch (IOException e) {
  79.                                         if (logger.isErrorEnabled()) {
  80.                                                 logger.error("run()", e);
  81.                                         }

  83.                                         e.printStackTrace();
  84.                                 }
  85.                         }
  86.                        
  87.                         if (fr != null) {
  88.                                 try {
  89.                                         fr.close();
  90.                                         fr = null;
  91.                                 } catch (IOException e) {
  92.                                         if (logger.isErrorEnabled()) {
  93.                                                 logger.error("run()", e);
  94.                                         }

  96.                                         e.printStackTrace();
  97.                                 }
  98.                         }
  99.                        
  100.                         exePool.shutdown();
  101.                         while (true) {
  102.                                 if (exePool.isTerminated()) {
  103.                                         System.out.println("ShutDown");
  104.                                         FileUtil.deleteFile(logFileBack);
  105.                                         break;
  106.                                 }
  107.                         }
  108.                        
  109.                 }
  110.         }
  111.        
  112.         private class AnalysisLogTask implements Runnable {
  113.                 //起始行
  114.                 private long beginLine;
  115.                
  116.                 //结束行
  117.                 private long endLine;
  118.                
  119.                 private String logFilePath;

  121.                 public AnalysisLogTask(String logFilePath, long beginLine, long endLine) {
  122.                         super();
  123.                         this.logFilePath = logFilePath;
  124.                         this.beginLine = beginLine;
  125.                         this.endLine = endLine;
  126.                 }

  128.                 @Override
  129.                 public void run() {
  130.                         FileReader fr = null;
  131.                         BufferedReader br = null;
  132.                         String tempStr = null;
  133.                         String[] tempArray = null;
  134.                         long currentLine = 0;
  135.                         List resultList = new ArrayList();
  136.                        
  137.                         ObjectActionDetail tempObjectActionDetailVO = null;
  138.                         try {
  139.                                 fr = new FileReader(logFilePath);
  140.                                 br = new BufferedReader(fr);
  141.                                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  142.                                
  143.                                 //跳过前置的行数
  144.                                 if (beginLine != 1) {
  145.                                         while ((currentLine < (beginLine-1)) && br.readLine() != null) {
  146.                                                 ++currentLine;
  147.                                         }
  148.                                 }
  149.                                
  150.                                 while ((tempStr = br.readLine()) != null && currentLine++ < endLine) {
  151.                                         tempArray = tempStr.split("\t");
  152.                                         tempObjectActionDetailVO = new ObjectActionDetail();

  154.                                         tempObjectActionDetailVO.setIp(tempArray[0]);
  155.                                         tempObjectActionDetailVO.setActionTime(sdf.parse(tempArray[1]));
  156.                                         tempObjectActionDetailVO.setSrcObjTypeId(Integer.parseInt(tempArray[2]));
  157.                                         tempObjectActionDetailVO.setSrcObjId(Integer.parseInt(tempArray[3]));
  158.                                         tempObjectActionDetailVO.setTarObjTypeId(Integer.parseInt(tempArray[4]));
  159.                                         tempObjectActionDetailVO.setTarObjId(Integer.parseInt(tempArray[5]));
  160.                                         tempObjectActionDetailVO.setActionId(Integer.parseInt(tempArray[6]));
  161.                                        
  162.                                         tempObjectActionDetailVO.setScore(0);
  163.                                         tempObjectActionDetailVO.setStatus(1);
  164.                                        
  165.                                         resultList.add(tempObjectActionDetailVO);
  166.                                 }
  167.                                
  168.                                 logger.info("Thread:" + Thread.currentThread().getName() + "   beginLine=" + beginLine + "   endLine=" + endLine);
  169.                                
  170.                                 objectActionDetailService.insertObjectActionDetailBatch(resultList);
  171.                         } catch (FileNotFoundException e) {
  172.                                 if (logger.isErrorEnabled()) {
  173.                                         logger.error("run()", e);
  174.                                 }

  176.                                 e.printStackTrace();
  177.                         } catch (IOException e) {
  178.                                 if (logger.isErrorEnabled()) {
  179.                                         logger.error("run()", e);
  180.                                 }

  182.                                 e.printStackTrace();
  183.                         } catch (ParseException e) {
  184.                                 if (logger.isErrorEnabled()) {
  185.                                         logger.error("run()", e);
  186.                                 }

  188.                                 e.printStackTrace();
  189.                         } finally {
  190.                                 if (br != null) {
  191.                                         try {
  192.                                                 br.close();
  193.                                                 br = null;
  194.                                         } catch (IOException e) {
  195.                                                 if (logger.isErrorEnabled()) {
  196.                                                         logger.error("run()", e);
  197.                                                 }

  199.                                                 e.printStackTrace();
  200.                                         }
  201.                                 }
  202.                                
  203.                                 if (fr != null) {
  204.                                         try {
  205.                                                 fr.close();
  206.                                                 fr = null;
  207.                                         } catch (IOException e) {
  208.                                                 if (logger.isErrorEnabled()) {
  209.                                                         logger.error("run()", e);
  210.                                                 }

  212.                                                 e.printStackTrace();
  213.                                         }
  214.                                 }
  215.                         }
  216.                 }
  217.         }
  218. }

今天又试验了一下先将整个文件拆分成小的单个文件，然后每个线程再解析自己的文件。测试后感觉这样的效果不好，明显不如多线程从一个文章读数据好，27分钟插入了100W条数据,平均一分钟3.7W条左右。怀疑是多线程读取文件，本地磁盘的I/O受限导致性能低下。 代码如下:

  1. /**
  2. * 分析Apache日志的定时任务.每天运行数次.
  3. *
  4. * @author Along
  5. *
  6. * @version $Revision$
  7. *
  8. * @since 2009-2-9
  9. */
  10. public class ApacheLogAnalysisTask {
  11.         /**
  12.          * Logger for this class
  13.          */
  14.         private static final Log logger = LogFactory.getLog(ApacheLogAnalysisTask.class);
  15.        
  16.         //总线程数
  17.         private static final int THREAD_COUNT = 10;
  18.        
  19.         //每个线程插入的日志数
  20.         private static final long LOG_COUNT_PER_THREAD = 3000;
  21.        
  22.         //日志文件的位置
  23.         private static final String LOG_FILE = Property.LOG_FILE_PATH + "/formatLog.txt";
  24.        
  25.         private IObjectActionDetailService objectActionDetailService;
  26.        

  28.         public void setObjectActionDetailService(IObjectActionDetailService objectActionDetailService) {
  29.                 this.objectActionDetailService = objectActionDetailService;
  30.         }

  32.         public void execute() {
  33.                 this.multiAnalysisLog();
  34.         }
  35.        
  36.         private void multiAnalysisLog() {
  37.                 ExecutorService exePool = Executors.newFixedThreadPool(THREAD_COUNT);
  38.                
  39.                 FileReader fr = null;
  40.                 FileWriter fw = null;
  41.                 BufferedReader br = null;
  42.                 int threadCount = 0;
  43.                 long tempLineCount = 0;
  44.                 String tempReadLineStr = null;
  45.                 long now = System.currentTimeMillis();
  46.                 String logFileBackFile = Property.LOG_FILE_PATH + "/old/formatLog_" + DateUtil.getSystemCurrentDate() + "_" + now + ".txt";
  47.                 String logFilePerThreadName = Property.LOG_FILE_PATH + "/old/formatLog_" + DateUtil.getSystemCurrentDate() + "_" + now;
  48.                
  49.                 try {
  50.                         //文件拷贝出来一个新的,并将原先的删除.
  51.                         FileUtil.copyfile(LOG_FILE, logFileBackFile, true);
  52.                         //FileUtil.deleteFile(LOG_FILE);
  53.                        
  54.                         fr = new FileReader(logFileBackFile);
  55.                         br = new BufferedReader(fr);
  56.                         fw = new FileWriter(logFilePerThreadName + "_" + ++threadCount + ".txt");
  57.                        
  58.                         while ((tempReadLineStr = br.readLine()) != null){
  59.                                 tempLineCount++;
  60.                                 fw.append(tempReadLineStr).append("\r\n");
  61.                                
  62.                                 //每个线程分配固定的行数
  63.                                 if(tempLineCount == LOG_COUNT_PER_THREAD) {
  64.                                         fw.flush();
  65.                                         fw.close();
  66.                                         exePool.execute(new AnalysisLogTask(logFilePerThreadName + "_" + threadCount + ".txt"));

  68.                                         //创建新的文件,临时变量清零.
  69.                                         fw = new FileWriter(logFilePerThreadName + "_" + ++threadCount + ".txt");
  70.                                         tempLineCount = 0;
  71.                                 }
  72.                         }
  73.                        
  74.                         //最后一个线程有文件则写入执行,没有,则删除最后一个建立的文件.
  75.                         if (tempLineCount != 0) {
  76.                                 fw.flush();
  77.                                 fw.close();
  78.                                 exePool.execute(new AnalysisLogTask(logFilePerThreadName + "_" + threadCount + ".txt"));
  79.                         } else {
  80.                                 fw.flush();
  81.                                 fw.close();
  82.                                
  83.                                 FileUtil.deleteFile(logFilePerThreadName + "_" + threadCount + ".txt");
  84.                         }

  86.                 } catch (FileNotFoundException e) {
  87.                         e.printStackTrace();
  88.                 } catch (IOException e) {
  89.                         e.printStackTrace();
  90.                 } finally {
  91.                         if (br != null) {
  92.                                 try {
  93.                                         br.close();
  94.                                         br = null;
  95.                                 } catch (IOException e) {
  96.                                         if (logger.isErrorEnabled()) {
  97.                                                 logger.error("run()", e);
  98.                                         }

  100.                                         e.printStackTrace();
  101.                                 }
  102.                         }
  103.                        
  104.                         if (fr != null) {
  105.                                 try {
  106.                                         fr.close();
  107.                                         fr = null;
  108.                                 } catch (IOException e) {
  109.                                         if (logger.isErrorEnabled()) {
  110.                                                 logger.error("run()", e);
  111.                                         }

  113.                                         e.printStackTrace();
  114.                                 }
  115.                         }
  116.                        
  117.                         FileUtil.deleteFile(logFileBackFile);
  118.                         logger.info("File has deleted:" + logFileBackFile);
  119.                        
  120.                         exePool.shutdown();
  121.                         //判断是不是所有的任务都执行完毕,执行完删除日志文件.
  122.                         while (true) {
  123.                                 if (exePool.isTerminated()) {
  124.                                         logger.info("All task has shutdown.");
  125.                                         break;
  126.                                 }
  127.                         }
  128.                        
  129.                 }
  130.         }
  131.        
  132.         private class AnalysisLogTask implements Runnable {

  134.                 //每个线程要处理的日志文件
  135.                 private String logFilePath;

  137.                 public AnalysisLogTask(String logFilePath) {
  138.                         super();
  139.                         this.logFilePath = logFilePath;
  140.                 }

  142.                 @Override
  143.                 public void run() {
  144.                         logger.info("Thread:" + Thread.currentThread().getName() + " running.");
  145.                        
  146.                         FileReader fr = null;
  147.                         BufferedReader br = null;
  148.                         String tempStr = null;
  149.                         String[] tempArray = null;
  150.                         List resultList = new ArrayList();
  151.                        
  152.                         ObjectActionDetail tempObjectActionDetailVO = null;
  153.                         try {
  154.                                 fr = new FileReader(logFilePath);
  155.                                 br = new BufferedReader(fr);
  156.                                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  157.                                
  158.                                 while ((tempStr = br.readLine()) != null) {
  159.                                         tempArray = tempStr.split("\t");
  160.                                         tempObjectActionDetailVO = new ObjectActionDetail();

  162.                                         tempObjectActionDetailVO.setIp(tempArray[0]);
  163.                                         tempObjectActionDetailVO.setActionTime(sdf.parse(tempArray[1]));
  164.                                         tempObjectActionDetailVO.setSrcObjTypeId(Integer.parseInt(tempArray[2]));
  165.                                         tempObjectActionDetailVO.setSrcObjId(Integer.parseInt(tempArray[3]));
  166.                                         tempObjectActionDetailVO.setTarObjTypeId(Integer.parseInt(tempArray[4]));
  167.                                         tempObjectActionDetailVO.setTarObjId(Integer.parseInt(tempArray[5]));
  168.                                         tempObjectActionDetailVO.setActionId(Integer.parseInt(tempArray[6]));
  169.                                        
  170.                                         tempObjectActionDetailVO.setScore(0);
  171.                                         tempObjectActionDetailVO.setStatus(1);
  172.                                        
  173.                                         resultList.add(tempObjectActionDetailVO);
  174.                                 }
  175.                                 objectActionDetailService.insertObjectActionDetailBatch(resultList);
  176.                         } catch (FileNotFoundException e) {
  177.                                 if (logger.isErrorEnabled()) {
  178.                                         logger.error("run()", e);
  179.                                 }

  181.                                 e.printStackTrace();
  182.                         } catch (IOException e) {
  183.                                 if (logger.isErrorEnabled()) {
  184.                                         logger.error("run()", e);
  185.                                 }

  187.                                 e.printStackTrace();
  188.                         } catch (ParseException e) {
  189.                                 if (logger.isErrorEnabled()) {
  190.                                         logger.error("run()", e);
  191.                                 }

  193.                                 e.printStackTrace();
  194.                         } finally {
  195.                                 if (br != null) {
  196.                                         try {
  197.                                                 br.close();
  198.                                                 br = null;
  199.                                         } catch (IOException e) {
  200.                                                 if (logger.isErrorEnabled()) {
  201.                                                         logger.error("run()", e);
  202.                                                 }

  204.                                                 e.printStackTrace();
  205.                                         }
  206.                                 }
  207.                                
  208.                                 if (fr != null) {
  209.                                         try {
  210.                                                 fr.close();
  211.                                                 fr = null;
  212.                                         } catch (IOException e) {
  213.                                                 if (logger.isErrorEnabled()) {
  214.                                                         logger.error("run()", e);
  215.                                                 }

  217.                                                 e.printStackTrace();
  218.                                         }
  219.                                 }
  220.                                
  221.                                 //删除本线程负责的日志文件
  222.                                 FileUtil.deleteFile(logFilePath);
  223.                                 logger.info("Thread:" + Thread.currentThread().getName() + "   logFilePath has deleted:" + logFilePath);
  224.                                 logger.info("Thread:" + Thread.currentThread().getName() + " shutdown.");
  225.                         }
  226.                 }
  227.         }
  228. }

后来又找系统管理员优化了一下网络，现在数据入库的速度是100W条7分钟 。相信应用和数据库移动到生产环境中，性能会进一步提升。

你可能感兴趣的:(BUG解决备忘录)

  • 设计模式 23 访问者模式 WineMonk #设计模式设计模式访问者模式
    设计模式23创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式23访问者模式（VisitorPattern）1定义2结构3
  • 这个桌面日历真不错 笔记 提醒 生日记录 打卡 翻译都有 真的太方便了！ C盘清理 实用软件笔记待办日历桌面日历电脑日历生日提醒记事本
    这个桌面日历真不错笔记提醒生日记录打卡翻译都有真的太方便了！日历产品非常的多，如何选择一个合适自己的桌面日历，这个很重要，今天小编给大家介绍这个芝麻日历，一起看下它有些什么功能，是不是你需要的。1、美观，一个实用的桌面日历，不仅要界面美观，还要功能强大；芝麻日历（https://rili.zhimasoft.cn/?abiw）芝麻日历下载实用的桌面日历万年历农历查询桌面便签/备忘录芝麻日历软件官方
  • iPhone备忘录清除缓存 HaloHoohoo 问题iphoneios缓存
    前言离剁手只有一张图，就是：遇到问题就去找方法，找方法就要找问题源头，经过我不懈的努力，我终于找到了万恶之源——备忘录。奇怪的是我的东西并不多，而且写图文总结的备忘录，一般都会放在iCloud上，前几日我一直是觉得自己的图片放得太多才导致如此，但狂删除的举动反而让其占用的存储更大了些，我震惊并生气。遂在几次连相机都打不开的时候怒摔（伪）手机并扬言13出来就把你扔了，只是13还得等，日子还得过，微信
  • 如何把小米手机便签内容云同步到iPhone XS上? weixin_34220179
    云同步指的是在云平台上以个人为中心的不同设备之间数据共享。那么小米手机与iPhoneXS都是支持用户个人云服务的设备，两款手机上备忘的内容能够实现共享吗？答案显而易见，不可以。因为两款手机系统不同，用来备忘的软件也不同，iPhonexs是以备忘录作为备忘软件，而小米用手机便签。那如何才能让小米手机与iPhoneXS手机实现备忘内容的云同步呢？可以通过能够多端云同步的敬业签来实现。敬业签云便签能够跨
  • 已经导出到电脑的荣耀手机便签如何打开 匠心� virtualenv
    手机便签往往记录着我们生活和工作中容易遗忘的信息，荣耀手机又比较耐用，用个两三年没有问题。两三年的时间，足以让我们在便签上记录很多内容了。如果需要在电脑上查看手机便签内容，该如何操作？如果已经导出到电脑上的手机便签内容，该如何打开？现在这篇文章就来详细解答一下这个问题。荣耀手机自带的便签叫备忘录，如果要把备忘录的内容传输到电脑上，用华为云账号就可以了。先在手机上把备忘录内容备份到云账号，然后在百度
  • 备忘录模式（Memento） 疯狂的阿吉 c++设计模式设计模式
    目录前言一、备忘录模式总结1、模式意图2、参与者3、结构、协作、适用性及效果二、备忘录模式简单示例1、用例描述2、示例代码总结前言本周五参加了Memento（备忘录）模式研讨会，本文的目的是对这个模式的总结和分享，希望对需要学习这个设计模式的同学有所帮助。本文一共分为两个部分，第一个部分是备忘录模式的基础知识总结；第二个部分是分享备忘录模式简单示例。一、备忘录模式总结1、模式意图在不破坏封装性的前
  • java设计模式---中介者模式 奔跑的扫地僧 Java设计模式java
    首先我们了解下设计模式的总览：GoF提出的设计模式总共有23种，根据目的准则分类分为三大类：创建型模式，共五种：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式
  • Java设计模式（二十二）行为型- 备忘录模式 Memento Pattern（史上最全备忘录模式）与使用场景以及优缺点 刘了个刘 java设计模式java设计模式备忘录模式
    备忘录模式MementoPattern备忘录模式又称为快照模式（SnapshotPattern）或令牌模式（TokenPattern），是指在不破坏封装的前提下，捕获一个对象的内部状态，并在对象之外保存这个状态，这样以后就可将该对象恢复到原先保存的状态。特征：“后悔药”备忘录模式的主要角色如下：发起人（Originator）角色：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能，实
  • 设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者 JunSIr_# 面向对象设计模式责任链命令观察者备忘录
    设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者文章目录设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者责任链模式（ChainofResponsibilityPattern）命令模式（CommandPattern）迭代器模式（IteratorPattern）备忘录模式（MementoPattern）观察者模式（Obse
  • 【秀娟习惯养成记—2020.10.16】 欧秀娟
    2020.10.16日习惯养成第54天每到周日，除了感叹时间过得快，还是感叹时间过得快，一天天，一周周，一月月，2020转眼就将接近尾声，年初定下的目标实现了多少？这一年又有哪些成长呢？多问问自己，珍惜当下的每分每秒，努力去做好一件件小事，不求最好，但求比昨天更好。在剩下来的两个多月时间里，在食饮有节上还要注意再注意，因为一到周末休息，不经意间总会吃多。此刻打开手机备忘录，坐在电脑前，开始完成迟到
  • 亚马逊AI产品Amazon Q被指出有各种问题，这将导致客户流失至微软 市象 人工智能网络科技
    近日，泄露的消息显示，亚马逊的重要AI产品AmazonQ在发布初期面临不少挑战，并且存在客户转向微软Copilot的风险。这款备受期待的产品在四月份公开发布后，遇到了一系列的问题。内部备忘录显示，八月份时，一些亚马逊网络服务（AWS）的员工在内部Slack频道中表达了对AmazonQ的看法，指出该产品存在功能不足、成本较高以及难以与其他软件集成等问题。更有员工担心，这些问题可能导致客户转投微软的C
  • 当代青年人格分裂图鉴 卫校一七药二
    分裂，并快乐着当代年轻人真是越活越分裂了。他们一面被动接收着来自社会、长辈的正能量“谆谆教诲”，一面私下里践行着“怎么爽怎么来”的生活哲学。在正能量和丧文化的频频交锋中，他们也在不知不觉间形成了诸多种矛盾人格，我们为各位盘点了以下十种类型的年轻人，相信总有几款是你熟悉的味道：）01每逢新年或xx节点，都是他们大批出没的高峰时段，备忘录里列得满满当当的todolist和朋友圈里洋洋洒洒的“新年献词”
  • 【Bug分析】Keil报错：error: #18:expected a “)“问题解决 Jason Yan 嵌入式系统开发bug单片机
    【Bug分析】Keil报错：error:#18:expecteda“）”问题解决前言bug查找bug解决方法小结前言keil编译时出现一个问题，缺少一个右括号。然后仔细查看代码，并没有括号缺失。如下，代码括号正常。bug查找站内文章以及评论看了下，都不在这些举例之中。keil编程时error:#65:expecteda“；“的解决办法只能自己想办法了，我原来是打算添加一个模块的，所以联想到可能某个
  • 软考-常见的23种设计模式整理 ppliu600 软件架构数据仓库数据库数据挖掘
    参考：23种设计模式总结设计模式可以将复用别人的解决方案。一、设计模式的分类创建型模式，共5种：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。结构型模式，共7种：适配器模式、组合模式、代理模式、享元模式、外观模式、桥接模式、装饰器模式、行为型模式，共11种：观察者模式、策略模式、模板方法模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
  • 姑娘，痛苦不是财富，对痛苦的思考才是财富 进击的Juju
    「我们面对同一个世界，却无法看见同一个世界。」《看见》，是知名记者和主持人柴静的一本自传性作品。第一次知道这本书，源于我读大学时新闻学导师的推荐。但其实这本书，不管是新闻从业者，还是普通读者都值得一看。书中有谈到非典、汶川地震、两会报道、北京奥运、华南虎照、征地调查等，可以说是中国社会十年变迁的备忘录。虽然都是社会性事件和调查，但柴静的文章，写得细致真诚，没有戾气，不刻意煽情，却依然直指内心。「她
  • 《收获》 阿拉萝卜
    你问我最近做了些什么收获如何我默然因为说不出来你看那些握在大脑皮层里的神经元那些散落在每本书的扉页每页笔记上的调皮的小清新那些被扔掉的彩色信纸上的勾勒对了还有躺在备忘录里的文字图片发自App它们要如何才能连在一起？我把生活铺成了满天星辰却抓不住任何一颗因为它们已经散漫得不想属于我
  • 设计模式漫谈之备忘录模式 weixin_34362790 设计模式
    最近很长时间没写博客了，其实这个博客写过一半，中间有事耽搁了，就没继续。主要是给别人做了一个小系统，及维护码云上的代码库。同居的日子也占了我很多时间。最近也是烦，欠了7W，各种烦事。所以可想写个博客静静心。在面向对象中关注的焦点是对象空间，对象与对象的联系还是通过保存引用（相当于路），来走到其空间中。在对象中是有空间的，空间里放的肯定是数据或者是命令。备忘录就是把A对象的空间数据，备份到B对象空间
  • 果然复盘010 果然越来越好
    果然复盘0102021-3-71今日收获①美图日更读书②关注一些阅读学习公众号，阿猫读书，杨熹文，绽放。读书美学，学习在路上。③文字记录，读书笔记。备忘录翻看到一篇去年的读书笔记，有内容有思考，现在看看居然仍然觉得有可读，果然是触发了思考。④复盘笔记，坚持写。简单的事，持久做。2今日反思①少即是多。挂在嘴上，但是学习上，还是会被精彩分享吸引。忍不住关注，结果又觉得时间不够用。②视频号很火，大家都在
  • Blender纹理绘制无效的几种解决方案（备忘录01） 2301_78998594 blender
    图片来源：b站：Nora仙仙仙https://www.bilibili.com/video/BV1x8411r76A/解决方案：1.1：到编辑模式下选中物体后重试；1.2（本人遇到的问题）：打开面朝向模式，蓝色的物体是正常物体，红色表示面朝向相反，你画的东西都在背面全选并SHIFT+N，就可以把面朝向反过来
  • Java设计模式【备忘录模式】-行为型 lianyinghhh Java设计模式
    1.介绍备忘录模式（MementoPattern）是一种行为型设计模式，允许在不破坏封装的前提下，捕获并保存一个对象的内部状态，然后可以在以后将其恢复到原先保存的状态。备忘录模式的核心思想是记录和恢复对象的状态，通常用于“撤销（undo）”操作中。备忘录模式涉及以下角色：发起人（Originator）：负责创建备忘录对象来存储其内部状态，并能够从备忘录对象中恢复其状态。备忘录（Memento）：存
  • 【无戒学堂】走出自己，走进人生 竹音尘
    鱼堂主分享会后之所思。图摘自鱼堂主分享，侵删以前听说过今日头条app,但是没有下载，也没有看过。知乎是下载了，但只关注了几次。是缘起于偶然的推荐app中才知道的创作自由app。说起来，好像是知乎中的推荐。于是，以前是间断性的。还是以日记本和备忘录为准记录生活。有了，就在上记录了。很多简友是学习的榜样。正能量，尽力向上，学到知识，涨知识。点评别人的文字，遇到心仪的故事会点评。记得刚开始进入。遇见了一
  • 设计模式 15 解释器模式 WineMonk #设计模式设计模式解释器模式
    设计模式15创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式15解释器模式（InterpreterPattern）1定义
  • iPhone备忘录不小心删除了怎么办？ m0_63254421 iphoneios
    在日常使用iPhone的过程中，备忘录作为我们记录重要信息、灵感闪现和日常琐事的小帮手，其重要性不言而喻。然而，有时候因为操作失误或是不小心点击，我们可能会将珍贵的备忘录内容删除，这无疑会让人感到焦虑与不安。但请放心，即使iPhone备忘录不小心被删除了，也并非没有挽回的余地。今天，我们就来探讨几种有效的恢复方法，帮助你找回那些遗失的记忆。一、利用“最近删除”文件夹iPhone的备忘录应用中，有一
  • 【Linux命令手册】速查、备忘录 Uncle 城 linux服务器运维计算机网络网络centos网络协议
    系统信息和性能查看常⽤命令作⽤uname-a查看内核/OS/CPU信息uname-r查看内核版本uname-m查看处理器架构arch查看处理器架构hostname查看计算机名who显示当前登录系统的⽤户whoami显示登录时的⽤户名whoami显示当前⽤户名cat/proc/version查看linux版本信息cat/proc/cpuinfo查看CPU信息cat/proc/interrupts查看
  • 这样也好 砖缝的小草
    每天我都要在晚上十点前写好第二天的更文，然后看会儿书睡觉。每天我都在有灵感的瞬间写下标题，只要有半个小时的空闲时间，我会很快的梳理思路，在备忘录写下或长或短的文章。每天我都在睁开眼睛的时候，快速浏览写好的文章，稍作修改去发布。今天一整天，我的灵感不断，一条条像跳跃的鱼儿涌出我的脑海，却没有瞬间的时间容我写下标题。此刻已经晚上九点半了，我打开备忘录，空空如也，难道我要断了日更。不，坚持是我的信仰。断
  • 设计模式 18 备忘录模式 WineMonk #设计模式设计模式备忘录模式
    设计模式18创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式18备忘录模式（MementoPattern）1定义2结构3
  • 行为型设计模式-备忘录（memento）模式 懂一点的陈老师 设计模式设计模式
    设计模式汇总：查看通俗示例想象一下你正在玩一个角色扮演游戏，在游戏中你有一个角色，随着游戏的进行，角色的状态会不断变化，比如经验值、装备和生命值等。如果游戏中没有保存功能，一旦游戏意外关闭或者你想要重新尝试某个决策，你将不得不重新开始游戏。但是，如果游戏提供了保存功能，你可以随时创建一个“快照”来记录当前角色的状态，如果后续出现了不利的局面，你可以回到这个“快照”来恢复角色的状态。这里的“快照”就
  • 求职路上 春风起梨花开
    每次和hr的谈话都像极了灵魂的拷问。为什么为什么为什么ps：最近学了一个小技巧，就是把要做的事都写在手机上备忘录里的待办，然后就可以把乱七八糟的事情整合，不会漏掉。做完的时候还可以设置成“已完成”，超有成就感的。虽然这次去是体验英语培训课程的，却像极了他们对我全部的否定。然后说，学英语，就是你的转折点，学英语，你可以进外企，开启人生巅峰。…无疑地，英语也算得上是一种语言能力，一个加分项。我宁愿自己
  • 纪念过去的一年 之III Eric77 生活游戏nokia手机360
    //2008-06-0311:03纪念过去的一年2005年6月3号是我从郑州坐了26个小时到达深圳的第一天.转眼间,我已经来到这个城市整整三年了.每年我都会尽量在这一天把上一年发生的事情写下来.可惜之前的那个nokia3105手机一不小心被摔坏了,新买的手机又没有了备忘录功能,所以很多生活中点点滴滴的心情就这样流失掉了.去年到底在想些什么呢?07年真是不堪回首,省略壹千零壹个字,伤害了不该伤害的人
  • BUG解决：postman可以请求成功，但Python requests请求报403 唯余木叶下弦声 bug
    目录问题背景问题定位问题解决问题背景使用Python的requests库对接物联数据的接口之前一直正常运行，昨天突然请求不通了，通过进一步验证发现凡是使用代码调用接口就不通，而使用postman就能调通，请求参数啥的都没变。接口返回的结果如下：\n\n\n\n\n403\n\nbody{\nbackground-color:#f3f3f4;\ncolor:#676a6c;\nheight:100%
  • 312个免费高速HTTP代理IP（能隐藏自己真实IP地址） yangshangchuan 高速免费superwordHTTP代理
        124.88.67.20:843 190.36.223.93:8080 117.147.221.38:8123 122.228.92.103:3128 183.247.211.159:8123 124.88.67.35:81 112.18.51.167:8123 218.28.96.39:3128 49.94.160.198:3128 183.20
  • pull解析和json编码 百合不是茶 androidpull解析json
    n.json文件: [{name:java,lan:c++,age:17},{name:android,lan:java,age:8}]   pull.xml文件 <?xml version="1.0" encoding="utf-8"?> <stu>     <name>java
  • [能源与矿产]石油与地球生态系统 comsci 能源
          按照苏联的科学界的说法,石油并非是远古的生物残骸的演变产物,而是一种可以由某些特殊地质结构和物理条件生产出来的东西,也就是说,石油是可以自增长的....       那么我们做一个猜想: 石油好像是地球的体液,我们地球具有自动产生石油的某种机制,只要我们不过量开采石油,并保护好
  • 类与对象浅谈 沐刃青蛟 java基础
           类，字面理解，便是同一种事物的总称，比如人类，是对世界上所有人的一个总称。而对象，便是类的具体化，实例化，是一个具体事物，比如张飞这个人，就是人类的一个对象。但要注意的是：张飞这个人是对象，而不是张飞，张飞只是他这个人的名字，是他的属性而已。而一个类中包含了属性和方法这两兄弟，他们分别用来描述对象的行为和性质（感觉应该是
  • 新站开始被收录后，我们应该做什么？ IT独行者 PHPseo
    新站开始被收录后，我们应该做什么？         百度终于开始收录自己的网站了，作为站长，你是不是觉得那一刻很有成就感呢，同时，你是不是又很茫然，不知道下一步该做什么了？至少我当初就是这样，在这里和大家一份分享一下新站收录后，我们要做哪些工作。       至于如何让百度快速收录自己的网站，可以参考我之前的帖子《新站让百
  • oracle 连接碰到的问题 文强chu oracle
    Unable to find a java Virtual Machine－－安装64位版Oracle11gR2后无法启动SQLDeveloper的解决方案 作者：草根IT网 来源：未知 人气：813标签： 导读：安装64位版Oracle11gR2后发现启动SQLDeveloper时弹出配置java.exe的路径，找到Oracle自带java.exe后产生的路径“C:\app\用户名\prod
  • Swing中按ctrl键同时移动鼠标拖动组件（类中多借口共享同一数据） 小桔子 java继承swing接口监听
            都知道java中类只能单继承，但可以实现多个接口，但我发现实现多个接口之后，多个接口却不能共享同一个数据，应用开发中想实现：当用户按着ctrl键时，可以用鼠标点击拖动组件，比如说文本框。 编写一个监听实现KeyListener,NouseListener,MouseMotionListener三个接口，重写方法。定义一个全局变量boolea
  • linux常用的命令 aichenglong linux常用命令
    1 startx切换到图形化界面 2 man命令:查看帮助信息 man 需要查看的命令,man命令提供了大量的帮助信息,一般可以分成4个部分 name:对命令的简单说明 synopsis:命令的使用格式说明 description:命令的详细说明信息 options:命令的各项说明 3 date:显示时间 语法：date [OPTION]... [+FORMAT]
  • eclipse内存优化 AILIKES javaeclipsejvmjdk
    一 基本说明      在JVM中，总体上分2块内存区,默认空余堆内存小于 40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。     1)堆内存(Heap memory):堆是运行时数据区域，所有类实例和数组的内存均从此处分配,是Java代码可及的内存，是留给开发人
  • 关键字的使用探讨 百合不是茶 关键字
    //关键字的使用探讨/*访问关键词private 只能在本类中访问public 只能在本工程中访问protected 只能在包中和子类中访问默认的 只能在包中访问*//*final   类 方法 变量 final 类 不能被继承 final 方法 不能被子类覆盖，但可以继承 final 变量 只能有一次赋值，赋值后不能改变 final 不能用来修饰构造方法*///this()
  • JS中定义对象的几种方式 bijian1013 js
        1. 基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)： <html> <head> <title>基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)</title> </head> <script> var obj = new Object();
  • 表驱动法实例 bijian1013 java表驱动法TDD
    获得月的天数是典型的直接访问驱动表方式的实例，下面我们来展示一下： MonthDaysTest.java package com.study.test; import org.junit.Assert; import org.junit.Test; import com.study.MonthDays; public class MonthDaysTest { @T
  • LInux启停重启常用服务器的脚本 bit1129 linux
    启动，停止和重启常用服务器的Bash脚本，对于每个服务器，需要根据实际的安装路径做相应的修改   #! /bin/bash Servers=(Apache2, Nginx, Resin, Tomcat, Couchbase, SVN, ActiveMQ, Mongo); Ops=(Start, Stop, Restart); currentDir=$(pwd); echo
  • 【HBase六】REST操作HBase bit1129 hbase
    HBase提供了REST风格的服务方便查看HBase集群的信息，以及执行增删改查操作   1. 启动和停止HBase REST 服务 1.1 启动REST服务 前台启动（默认端口号8080） [hadoop@hadoop bin]$ ./hbase rest start   后台启动 hbase-daemon.sh start rest   启动时指定
  • 大话zabbix 3.0设计假设 ronin47
    What’s new in Zabbix 2.0? 去年开始使用Zabbix的时候，是1.8.X的版本，今年Zabbix已经跨入了2.0的时代。看了2.0的release notes，和performance相关的有下面几个：          :: Performance improvements::Trigger related da
  • http错误码大全 byalias http协议javaweb
    响应码由三位十进制数字组成，它们出现在由HTTP服务器发送的响应的第一行。 响应码分五种类型，由它们的第一位数字表示： 1）1xx：信息，请求收到，继续处理 2）2xx：成功，行为被成功地接受、理解和采纳 3）3xx：重定向，为了完成请求，必须进一步执行的动作 4）4xx：客户端错误，请求包含语法错误或者请求无法实现 5）5xx：服务器错误，服务器不能实现一种明显无效的请求
  • J2EE设计模式-Intercepting Filter bylijinnan java设计模式数据结构
    Intercepting Filter类似于职责链模式 有两种实现 其中一种是Filter之间没有联系，全部Filter都存放在FilterChain中，由FilterChain来有序或无序地把把所有Filter调用一遍。没有用到链表这种数据结构。示例如下： package com.ljn.filter.custom; import java.util.ArrayList;
  • 修改jboss端口 chicony jboss
    修改jboss端口   %JBOSS_HOME%\server\{服务实例名}\conf\bindingservice.beans\META-INF\bindings-jboss-beans.xml   中找到 <!-- The ports-default bindings are obtained by taking the base bindin
  • c++ 用类模版实现数组类 CrazyMizzz C++
    最近c++学到数组类，写了代码将他实现，基本具有vector类的功能 #include<iostream> #include<string> #include<cassert> using namespace std; template<class T> class Array { public: //构造函数
  • hadoop dfs.datanode.du.reserved 预留空间配置方法 daizj hadoop预留空间
    对于datanode配置预留空间的方法 为：在hdfs-site.xml添加如下配置  <property>     <name>dfs.datanode.du.reserved</name>     <value>10737418240</value>    
  • mysql远程访问的设置 dcj3sjt126com mysql防火墙
    第一步: 激活网络设置 你需要编辑mysql配置文件my.cnf. 通常状况，my.cnf放置于在以下目录： /etc/mysql/my.cnf (Debian linux) /etc/my.cnf （Red Hat Linux/Fedora Linux) /var/db/mysql/my.cnf (FreeBSD) 然后用vi编辑my.cnf，修改内容从以下行： [mysqld] 你所需要: 1
  • ios 使用特定的popToViewController返回到相应的Controller dcj3sjt126com controller
    1、取navigationCtroller中的Controllers NSArray * ctrlArray = self.navigationController.viewControllers; 2、取出后，执行， [self.navigationController popToViewController:[ctrlArray objectAtIndex:0] animated:YES
  • Linux正则表达式和通配符的区别 eksliang 正则表达式通配符和正则表达式的区别通配符
    转载请出自出处：http://eksliang.iteye.com/blog/1976579 首先得明白二者是截然不同的 通配符只能用在shell命令中,用来处理字符串的的匹配。 判断一个命令是否为bash shell(linux 默认的shell)的内置命令 type -t commad 返回结果含义 file  表示为外部命令 alias  表示该
  • Ubuntu Mysql Install and CONF gengzg Install
    http://www.navicat.com.cn/download/navicat-for-mysql Step1: 下载Navicat ，网址：http://www.navicat.com/en/download/download.html Step2：进入下载目录，解压压缩包：tar -zxvf navicat11_mysql_en.tar.gz
  • 批处理，删除文件bat huqiji windowsdos
    @echo off ::演示：删除指定路径下指定天数之前（以文件名中包含的日期字符串为准）的文件。 ::如果演示结果无误，把del前面的echo去掉，即可实现真正删除。 ::本例假设文件名中包含的日期字符串（比如：bak-2009-12-25.log） rem 指定待删除文件的存放路径 set SrcDir=C:/Test/BatHome rem 指定天数 set DaysAgo=1
  • 跨浏览器兼容的HTML5视频音频播放器 天梯梦 html5
    HTML5的video和audio标签是用来在网页中加入视频和音频的标签，在支持html5的浏览器中不需要预先加载Adobe Flash浏览器插件就能轻松快速的播放视频和音频文件。而html5media.js可以在不支持html5的浏览器上使video和audio标签生效。   How to enable <video> and <audio> tags in
  • Bundle自定义数据传递 hm4123660 androidSerializable自定义数据传递BundleParcelable
          我们都知道Bundle可能过put****()方法添加各种基本类型的数据，Intent也可以通过putExtras(Bundle)将数据添加进去，然后通过startActivity()跳到下一下Activity的时候就把数据也传到下一个Activity了。如传递一个字符串到下一个Activity   把数据放到Intent
  • C＃：异步编程和线程的使用（.NET 4.5 ） powertoolsteam .net线程C#异步编程
    异步编程和线程处理是并发或并行编程非常重要的功能特征。为了实现异步编程，可使用线程也可以不用。将异步与线程同时讲，将有助于我们更好的理解它们的特征。 本文中涉及关键知识点 1. 异步编程 2. 线程的使用 3. 基于任务的异步模式 4. 并行编程 5. 总结 异步编程 什么是异步操作？异步操作是指某些操作能够独立运行，不依赖主流程或主其他处理流程。通常情况下，C＃程序
  • spark 查看 job history 日志 Stark_Summer 日志sparkhistoryjob
    SPARK_HOME/conf 下: spark-defaults.conf 增加如下内容 spark.eventLog.enabled true spark.eventLog.dir hdfs://master:8020/var/log/spark spark.eventLog.compress true spark-env.sh 增加如下内容 export SP
  • SSH框架搭建 wangxiukai2015eye springHibernatestruts
    MyEclipse搭建SSH框架 Struts Spring Hibernate 1、new一个web project。 2、右键项目，为项目添加Struts支持。    选择Struts2 Core Libraries -<MyEclipes-Library>      点击Finish。src目录下多了struts
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他