flume学习（五）：Flume Channel Selectors使用

摘要： 前几篇文章只有一个项目的日志，现在我们考虑多个项目的日志的收集，我拷贝了一份flumedemo项目,重命名为flumedemo2,添加了一个WriteLog2.java类，稍微改动了一下JSON字符串的输出，将以前requestUrl中的”reporter-api”改为了”image-api”,以...

前几篇文章只有一个项目的日志，现在我们考虑多个项目的日志的收集，我拷贝了一份flumedemo项目,重命名为flumedemo2,添加了一个WriteLog2.java类，稍微改动了一下JSON字符串的输出，将以前requestUrl中的”reporter-api”改为了”image-api”,以便和WriteLog类的输出稍微区分开来，如下：

package com.besttone.flume;

import java.util.Date;

import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

 public class WriteLog2 {
    protected static final Log logger = LogFactory.getLog(WriteLog2.class);

    /**
      * @param args
     * @throws InterruptedException
      */
    public static void main(String[] args) throws InterruptedException {
         // TODO Auto-generated method stub
        while (true) {
             logger.info(new Date().getTime());
            logger.info(“{\”requestTime\”:”
                     + System.currentTimeMillis()
                    + “,\”requestParams\”:{\”timestamp\”:1405499314238,\”phone\”:\”02038824941\”,\”cardName\”:\”测试商家名称\”,\”provinceCode\”:\”440000\”,\”cityCode\”:\”440106\”},\”requestUrl\”:\”/image-api/reporter/reporter12/init.do\”}”);
             Thread.sleep(2000);

         }
    }
 }

现在有这么一个需求描述：要求flumedemo的项目的log4j日志输出到hdfs,而flumedemo2项目的log4j日志输出到agent的log日志中。

我们还是采用log4jappender来配置log4j输出给flume的souce,现在的需求明显是有两个sink了，一个sink为hdfs,一个sink为logger。于是现在的拓扑结构应该是这样的：

需要实现这么一个拓扑接口，就需要使用到channel selectors，让不同的项目日志通过不同的channel到不同的sink中去。

官方文档上channel selectors 有两种类型:

Replicating Channel Selector (default)

Multiplexing Channel Selector

这两种selector的区别是:Replicating 会将source过来的events发往所有channel,而Multiplexing 可以选择该发往哪些channel。对于上面的例子来说，如果采用Replicating ,那么demo和demo2的日志会同时发往channel1和channel2,这显然是和需求不符的，需求只是让demo的日志发往channel1,而demo2的日志发往channel2。

综上所述，我们选择Multiplexing Channel Selector。这里我们有遇到一个棘手的问题，Multiplexing 需要判断header里指定key的值来决定分发到某个具体的channel，我们现在demo和demo2同时运行在同一个服务器上，如果在不同的服务器上运行，我们可以在 source1上加上一个 host 拦截器（上一篇有介绍过），这样可以通过header中的host来判断event该分发给哪个channel，而这里是在同一个服务器上，由host是区分不出来日志的来源的，我们必须想办法在header中添加一个key来区分日志的来源。

设想一下，如果header中有一个key:flume.client.log4j.logger.source,我们通过设置这个key的值，demo设为app1,demo2设为app2,这样我们就能通过设置：

tier1.sources.source1.channels=channel1 channel2
tier1.sources.source1.selector.type=multiplexing
tier1.sources.source1.selector.header=flume.client.log4j.logger.source
tier1.sources.source1.selector.mapping.app1=channel1
tier1.sources.source1.selector.mapping.app2=channel2

来将不同项目的的日志输出到不同的channel了。

我们按照这个思路继续下去，遇到了困难，log4jappender没有这样的参数来让你设置。怎么办？翻看了一下log4jappender的源码，发现可以很容易的实现扩展参数，于是我复制了一份log4jappender代码，新加了一个类叫Log4jExtAppender.java,里面扩展了一个参数叫：source,代码如下：

package com.besttone.flume;

import java.io.ByteArrayOutputStream;
 import java.io.IOException;
import java.nio.charset.Charset;
 import java.util.HashMap;
import java.util.Map;
 import java.util.Properties;

 import org.apache.avro.Schema;
import org.apache.avro.generic.GenericRecord;
 import org.apache.avro.io.BinaryEncoder;
import org.apache.avro.io.DatumWriter;
 import org.apache.avro.io.EncoderFactory;
import org.apache.avro.reflect.ReflectData;
 import org.apache.avro.reflect.ReflectDatumWriter;
import org.apache.avro.specific.SpecificRecord;
 import org.apache.flume.Event;
import org.apache.flume.EventDeliveryException;
 import org.apache.flume.FlumeException;
import org.apache.flume.api.RpcClient;
 import org.apache.flume.api.RpcClientConfigurationConstants;
import org.apache.flume.api.RpcClientFactory;
 import org.apache.flume.clients.log4jappender.Log4jAvroHeaders;
import org.apache.flume.event.EventBuilder;
 import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.helpers.LogLog;
 import org.apache.log4j.spi.LoggingEvent;

 /**
 *
  * Appends Log4j Events to an external Flume client which is decribed by the
 * Log4j configuration file. The appender takes two required parameters:
  *
 * Hostname : This is the hostname of the first hop at which
  * Flume (through an AvroSource) is listening for events.
 *
  *
 * Port : This the port on the above host where the Flume
  * Source is listening for events.
 *
  * A sample log4j properties file which appends to a source would look like:
 *
  *
 *
  * log4j.appender.out2 = org.apache.flume.clients.log4jappender.Log4jAppender
 * log4j.appender.out2.Port = 25430
  * log4j.appender.out2.Hostname = foobarflumesource.com
 * log4j.logger.org.apache.flume.clients.log4jappender = DEBUG,out2
  *
 *
  * Note: Change the last line to the package of the class(es), that will do
  * appending, the last line would be:
 *
  *
 *
  * log4j.logger.com.bar.foo = DEBUG,out2
 *
  *
 *
  */
public class Log4jExtAppender extends AppenderSkeleton {

    private String hostname;
     private int port;
    private String source;

    public String getSource() {
         return source;
    }

    public void setSource(String source) {
         this.source = source;
    }

    private boolean unsafeMode = false;
     private long timeout = RpcClientConfigurationConstants.DEFAULT_REQUEST_TIMEOUT_MILLIS;
    private boolean avroReflectionEnabled;
     private String avroSchemaUrl;

     RpcClient rpcClient = null;

     /**
     * If this constructor is used programmatically rather than from a log4j
      * conf you must set the port and hostname and then call
     * activateOptions() before calling append().
      */
    public Log4jExtAppender() {
     }

     /**
     * Sets the hostname and port. Even if these are passed the
      * activateOptions() function must be called before calling
     * append(), else append() will throw an Exception.
      *
     * @param hostname
      *            The first hop where the client should connect to.
     * @param port
      *            The port to connect on the host.
     *
      */
    public Log4jExtAppender(String hostname, int port, String source) {
         this.hostname = hostname;
        this.port = port;
         this.source = source;
    }

    /**
      * Append the LoggingEvent, to send to the first Flume hop.
     *
      * @param event
     *            The LoggingEvent to be appended to the flume.
      * @throws FlumeException
     *             if the appender was closed, or the hostname and port were not
      *             setup, there was a timeout, or there was a connection error.
     */
     @Override
    public synchronized void append(LoggingEvent event) throws FlumeException {
         // If rpcClient is null, it means either this appender object was never
        // setup by setting hostname and port and then calling activateOptions
         // or this appender object was closed by calling close(), so we throw an
        // exception to show the appender is no longer accessible.
         if (rpcClient == null) {
            String errorMsg = “Cannot Append to Appender! Appender either closed or”
                     + ” not setup correctly!”;
            LogLog.error(errorMsg);
             if (unsafeMode) {
                return;
             }
            throw new FlumeException(errorMsg);
         }

         if (!rpcClient.isActive()) {
            reconnect();
         }

         // Client created first time append is called.
        Map hdrs = new HashMap();
         hdrs.put(Log4jAvroHeaders.LOGGER_NAME.toString(), event.getLoggerName());
        hdrs.put(Log4jAvroHeaders.TIMESTAMP.toString(),
                 String.valueOf(event.timeStamp));

         // 添加日志来源
        if (this.source == null || this.source.equals(“”)) {
             this.source = “unknown”;
        }
         hdrs.put(“flume.client.log4j.logger.source”, this.source);
        // To get the level back simply use
         // LoggerEvent.toLevel(hdrs.get(Integer.parseInt(
        // Log4jAvroHeaders.LOG_LEVEL.toString()))
         hdrs.put(Log4jAvroHeaders.LOG_LEVEL.toString(),
                String.valueOf(event.getLevel().toInt()));

        Event flumeEvent;
         Object message = event.getMessage();
        if (message instanceof GenericRecord) {
             GenericRecord record = (GenericRecord) message;
            populateAvroHeaders(hdrs, record.getSchema(), message);
             flumeEvent = EventBuilder.withBody(
                    serialize(record, record.getSchema()), hdrs);
         } else if (message instanceof SpecificRecord || avroReflectionEnabled) {
            Schema schema = ReflectData.get().getSchema(message.getClass());
             populateAvroHeaders(hdrs, schema, message);
            flumeEvent = EventBuilder
                     .withBody(serialize(message, schema), hdrs);
        } else {
             hdrs.put(Log4jAvroHeaders.MESSAGE_ENCODING.toString(), “UTF8″);
            String msg = layout != null ? layout.format(event) : message
                     .toString();
            flumeEvent = EventBuilder.withBody(msg, Charset.forName(“UTF8″),
                     hdrs);
        }

        try {
             rpcClient.append(flumeEvent);
        } catch (EventDeliveryException e) {
             String msg = “Flume append() failed.”;
            LogLog.error(msg);
             if (unsafeMode) {
                return;
             }
            throw new FlumeException(msg + ” Exception follows.”, e);
         }
    }

    private Schema schema;
     private ByteArrayOutputStream out;
    private DatumWriter writer;   
          private BinaryEncoder encoder;   
        
          protected void populateAvroHeaders(Map hdrs, Schema schema,   
                 Object message) {   
              if (avroSchemaUrl != null) {   
                 hdrs.put(Log4jAvroHeaders.AVRO_SCHEMA_URL.toString(), avroSchemaUrl);   
                  return;   
             }   
              LogLog.warn(“Cannot find ID for schema. Adding header for schema, “   
                     + “which may be inefficient. Consider setting up an Avro Schema Cache.”);   
              hdrs.put(Log4jAvroHeaders.AVRO_SCHEMA_LITERAL.toString(),   
                     schema.toString());   
          }   
        
          private byte[] serialize(Object datum, Schema datumSchema)   
                 throws FlumeException {   
              if (schema == null || !datumSchema.equals(schema)) {   
                 schema = datumSchema;   
                  out = new ByteArrayOutputStream();   
                 writer = new ReflectDatumWriter(schema);   
                  encoder = EncoderFactory.get().binaryEncoder(out, null);   
             }   
              out.reset();   
             try {   
                  writer.write(datum, encoder);   
                 encoder.flush();   
                  return out.toByteArray();   
             } catch (IOException e) {   
                  throw new FlumeException(e);   
             }   
          }   
        
          // This function should be synchronized to make sure one thread   
         // does not close an appender another thread is using, and hence risking   
          // a null pointer exception.   
         /**  
           * Closes underlying client. If append() is called after this  
          * function is called, it will throw an exception.  
           *   
          * @throws FlumeException  
           *             if errors occur during close  
          */   
          @Override   
         public synchronized void close() throws FlumeException {   
              // Any append calls after this will result in an Exception.   
             if (rpcClient != null) {   
                  try {   
                     rpcClient.close();   
                  } catch (FlumeException ex) {   
                     LogLog.error(“Error while trying to close RpcClient.”, ex);   
                      if (unsafeMode) {   
                         return;   
                      }   
                     throw ex;   
                  } finally {   
                     rpcClient = null;   
                  }   
             } else {   
                  String errorMsg = “Flume log4jappender already closed!”;   
                 LogLog.error(errorMsg);   
                  if (unsafeMode) {   
                     return;   
                  }   
                 throw new FlumeException(errorMsg);   
              }   
         }   
         
         @Override   
          public boolean requiresLayout() {   
             // This method is named quite incorrectly in the interface. It should   
              // probably be called canUseLayout or something. According to the docs,   
             // even if the appender can work without a layout, if it can work with   
              // one,   
             // this method must return true.   
              return true;   
         }   
         
         /**  
           * Set the first flume hop hostname.  
          *   
           * @param hostname  
          *            The first hop where the client should connect to.  
           */   
         public void setHostname(String hostname) {   
              this.hostname = hostname;   
         }   
         
         /**  
           * Set the port on the hostname to connect to.  
          *   
           * @param port  
          *            The port to connect on the host.  
           */   
         public void setPort(int port) {   
              this.port = port;   
         }   
         
         public void setUnsafeMode(boolean unsafeMode) {   
              this.unsafeMode = unsafeMode;   
         }   
         
         public boolean getUnsafeMode() {   
              return unsafeMode;   
         }   
         
         public void setTimeout(long timeout) {   
              this.timeout = timeout;   
         }   
         
         public long getTimeout() {   
              return this.timeout;   
         }   
         
         public void setAvroReflectionEnabled(boolean avroReflectionEnabled) {   
              this.avroReflectionEnabled = avroReflectionEnabled;   
         }   
         
         public void setAvroSchemaUrl(String avroSchemaUrl) {   
              this.avroSchemaUrl = avroSchemaUrl;   
         }   
         
         /**  
           * Activate the options set using setPort() and  
          * setHostname()  
           *   
          * @throws FlumeException  
           *             if the hostname and port combination is  
          *             invalid.  
           */   
         @Override   
          public void activateOptions() throws FlumeException {   
             Properties props = new Properties();   
              props.setProperty(RpcClientConfigurationConstants.CONFIG_HOSTS, “h1″);   
             props.setProperty(RpcClientConfigurationConstants.CONFIG_HOSTS_PREFIX   
                      + “h1″, hostname + “:” + port);   
             props.setProperty(   
                      RpcClientConfigurationConstants.CONFIG_CONNECT_TIMEOUT,   
                     String.valueOf(timeout));   
              props.setProperty(   
                     RpcClientConfigurationConstants.CONFIG_REQUEST_TIMEOUT,   
                      String.valueOf(timeout));   
             try {   
                  rpcClient = RpcClientFactory.getInstance(props);   
                 if (layout != null) {   
                      layout.activateOptions();   
                 }   
              } catch (FlumeException e) {   
                 String errormsg = “RPC client creation failed! “ + e.getMessage();   
                  LogLog.error(errormsg);   
                 if (unsafeMode) {   
                      return;   
                 }   
                  throw e;   
             }   
          }   
        
          /**  
          * Make it easy to reconnect on failure  
           *   
          * @throws FlumeException  
           */   
         private void reconnect() throws FlumeException {   
              close();   
             activateOptions();   
          }   
     }   
     
    
     然后然后将这个类打了一个jar包：Log4jExtAppender.jar，扔在了flumedemo和flumedemo2的lib目录下。 
    这时候flumedemo的log4j.properties如下： 
   log4j.rootLogger=INFO


 log4j.category.com.besttone=INFO,flume,console,LogFile

 #log4j.appender.flume = org.apache.flume.clients.log4jappender.Log4jExtAppender
log4j.appender.flume = com.besttone.flume.Log4jExtAppender
 log4j.appender.flume.Hostname = localhost
log4j.appender.flume.Port = 44444
 log4j.appender.flume.UnsafeMode = false
log4j.appender.flume.Source = app1


 log4j.appender.console= org.apache.log4j.ConsoleAppender
log4j.appender.console.Target= System.out
 log4j.appender.console.layout= org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern= %d{yyyy-MM-dd HH:mm:ss} %5p %c{1}: %L – %m%n

log4j.appender.LogFile= org.apache.log4j.DailyRollingFileAppender
 log4j.appender.LogFile.File= logs/app.log
log4j.appender.LogFile.MaxFileSize=10KB
 log4j.appender.LogFile.Append= true
log4j.appender.LogFile.Threshold= DEBUG
 log4j.appender.LogFile.layout= org.apache.log4j.PatternLayout
log4j.appender.LogFile.layout.ConversionPattern= %-d{yyyy-MM-dd HH:mm:ss} [%t:%r] – [%5p] %m%n 
     flumedemo2的如下： 
   log4j.rootLogger=INFO


 log4j.category.com.besttone=INFO,flume,console,LogFile

 #log4j.appender.flume = org.apache.flume.clients.log4jappender.Log4jExtAppender
log4j.appender.flume = com.besttone.flume.Log4jExtAppender
 log4j.appender.flume.Hostname = localhost
log4j.appender.flume.Port = 44444
 log4j.appender.flume.UnsafeMode = false
log4j.appender.flume.Source = app2


 log4j.appender.console= org.apache.log4j.ConsoleAppender
log4j.appender.console.Target= System.out
 log4j.appender.console.layout= org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern= %d{yyyy-MM-dd HH:mm:ss} %5p %c{1}: %L – %m%n

log4j.appender.LogFile= org.apache.log4j.DailyRollingFileAppender
 log4j.appender.LogFile.File= logs/app.log
log4j.appender.LogFile.MaxFileSize=10KB
 log4j.appender.LogFile.Append= true
log4j.appender.LogFile.Threshold= DEBUG
 log4j.appender.LogFile.layout= org.apache.log4j.PatternLayout
log4j.appender.LogFile.layout.ConversionPattern= %-d{yyyy-MM-dd HH:mm:ss} [%t:%r] – [%5p] %m%n 
     将原来的log4j.appender.flume 由org.apache.flume.clients.log4jappender.Log4jExtAppender改为了我重新实现添加了source参数的com.besttone.flume.Log4jExtAppender 
    然后flumedemo的log4j.appender.flume.Source = app1，flumedemo2的log4j.appender.flume.Source = app2。 
    运行flumedemo的WriteLog类，和和flumedemo2的WriteLog2类，分别去hdfs上和agent的log文件中看看内容，发现hdfs上都是app1的日志，log文件中都是app2的日志，功能实现。 
    完整的flume.conf如下： 
   tier1.sources=source1
 tier1.channels=channel1 channel2
tier1.sinks=sink1 sink2
 tier1.sources.source1.type=avro
tier1.sources.source1.bind=0.0.0.0
 tier1.sources.source1.port=44444
tier1.sources.source1.channels=channel1 channel2
 tier1.sources.source1.selector.type=multiplexing
tier1.sources.source1.selector.header=flume.client.log4j.logger.source
 tier1.sources.source1.selector.mapping.app1=channel1
tier1.sources.source1.selector.mapping.app2=channel2
 tier1.sources.source1.interceptors=i1 i2
tier1.sources.source1.interceptors.i1.type=regex_filter
 tier1.sources.source1.interceptors.i1.regex=\\{.*\\}
tier1.sources.source1.interceptors.i2.type=timestamp
 tier1.channels.channel1.type=memory
tier1.channels.channel1.capacity=10000
 tier1.channels.channel1.transactionCapacity=1000
tier1.channels.channel1.keep-alive=30
 tier1.channels.channel2.type=memory
tier1.channels.channel2.capacity=10000
 tier1.channels.channel2.transactionCapacity=1000
tier1.channels.channel2.keep-alive=30
 tier1.sinks.sink1.type=hdfs
tier1.sinks.sink1.channel=channel1
 tier1.sinks.sink1.hdfs.path=hdfs://master68:8020/flume/events/%y-%m-%d
tier1.sinks.sink1.hdfs.round=true
 tier1.sinks.sink1.hdfs.roundValue=10
tier1.sinks.sink1.hdfs.roundUnit=minute
 tier1.sinks.sink1.hdfs.fileType=DataStream
tier1.sinks.sink1.hdfs.writeFormat=Text
 tier1.sinks.sink1.hdfs.rollInterval=0
tier1.sinks.sink1.hdfs.rollSize=10240
 tier1.sinks.sink1.hdfs.rollCount=0
tier1.sinks.sink1.hdfs.idleTimeout=60
 tier1.sinks.sink2.type=logger
tier1.sinks.sink2.channel=channel2 
   
  

                            
                        
                    
                    
                    
                    
                    
                    
                
                
                    
                        
                        
                             
                        
                        
                        
                            
                        
                        
                        
                            
                        
                    
                
            
        
    
    
        你可能感兴趣的:(flume)
        
            
                
                    数据仓库与数据挖掘记录 三
                        匆匆整棹还
数据挖掘
                        数据仓库的数据存储和处理数据的ETL过程数据ETL是用来实现异构数据源的数据集成,即完成数据的抓取/抽取、清洗、转换.加载与索引等数据调和工作,如图2.2所示。1）数据提取（Extract）从多个数据源中获取原始数据（如数据库、日志文件、API、云存储等）。数据源可能是结构化（如MySQL）、半结构化（如JSON）、非结构化（如文本）。关键技术：SQL查询、Web爬虫、日志采集工具（如Flume）
                    
                    【大数据技术】搭建完全分布式高可用大数据集群（Flume）
                        Want595
Python大数据采集与分析大数据分布式flume
                        搭建完全分布式高可用大数据集群（Flume）apache-flume-1.11.0-bin.tar.gz注：请在阅读本篇文章前，将以上资源下载下来。写在前面本文主要介绍搭建完全分布式高可用集群Flume的详细步骤。注意：统一约定将软件安装包存放于虚拟机的/software目录下，软件安装至/opt目录下。安装Flume用finalshell将压缩包上传到虚拟机master的/software目录下
                    
                    计算机毕业设计hadoop+spark+hive新能源汽车数据分析可视化大屏 汽车推荐系统 新能源汽车推荐系统 汽车爬虫 汽车大数据 机器学习 大数据毕业设计 深度学习 知识图谱 人工智能
                        qq+593186283
hadoop大数据人工智能
                        （1）设计目的本次设计一个基于Hive的新能源汽车数据仓管理系统。企业管理员登录系统后可以在汽车保养时，根据这些汽车内置传感器传回的数据分析其故障原因，以便维修人员更加及时准确处理相关的故障问题。或者对这些数据分析之后向车主进行预警提示车主注意保养汽车，以提高汽车行驶的安全系数。（2）设计要求利用Flume进行分布式的日志数据采集，Kafka实现高吞吐量的数据传输，DateX进行数据清洗、转换和整
                    
                    python消费kafka数据nginx日志实时_基于nginx+flume+kafka+mongodb实现埋点数据采集
                        weixin_39534208

                        名词解释埋点其实就是用于记录用户在页面的一些操作行为。例如，用户访问页面(PV，PageViews)、访问页面用户数量(UV,UserViews)、页面停留、按钮点击、文件下载等，这些都属于用户的操作行为。开发背景我司之前在处理埋点数据采集时，模式很简单，当用户操作页面控件时，前端监听到操作事件，并根据上下文环境，将事件相关的数据通过接口调用发送至埋点数据采集服务(简称ets服务)，ets服务对数
                    
                    大数据-267 实时数仓 - ODS Lambda架构 Kappa架构 核心思想
                        m0_74823336
面试学习路线阿里巴巴大数据架构
                        点一下关注吧！！！非常感谢！！持续更新！！！Java篇开始了！MyBatis更新完毕目前开始更新Spring，一起深入浅出！目前已经更新到了：Hadoop（已更完）HDFS（已更完）MapReduce（已更完）Hive（已更完）Flume（已更完）Sqoop（已更完）Zookeeper（已更完）HBase（已更完）Redis（已更完）Kafka（已更完）Spark（已更完）Flink（已更完）Cl
                    
                    nginx+flume网络流量日志实时数据分析实战_日志数据分析(1)
                        2401_84182578
程序员nginxflume数据分析
                        得到visits模型hadoopjar/export/data/mapreduce/web_log.jarcn.itcast.bigdata.weblog.clickstream.ClickStreamVisit网络日志数据分析-数据加载对于日志数据的分析，Hive也分为三层：ods层、dw层、app层创建数据库createdatabaseifnotexistsweb_log_ods;create
                    
                    【大数据入门核心技术-Flume】（二）Flume安装部署
                        forest_long
大数据技术入门到21天通关bigdatahadoop大数据hbaseflume
                        目录一、准备工作1、基本Hadoop环境安装2、下载安装包二、安装1、解压2、修改环境变量3、修改并配置flume-env.sh文件4、验证是否安装成功一、准备工作1、基本Hadoop环境安装参考Hadoop安装【大数据入门核心技术-Hadoop】（五）Hadoop3.2.1非高可用集群搭建【大数据入门核心技术-Hadoop】（六）Hadoop3.2.1高可用集群搭建2、下载安装包官方网址：
                    
                    java.io.FileNotFoundException: /tmp/log/flume-ng/flume.log (Permission denied)
                        海洋 之心
Flume问题解决Hadoop问题解决javaflume开发语言zookeeper大数据
                        文章目录问题描述：原因分析：解决方案：问题描述：使用Flume将本地文件监控上传到HDFS上时出现log4j:ERRORsetFile(null,true)callfailed.java.io.FileNotFoundException:/tmp/log/flume-ng/flume.log(Permissiondenied)log4j:ERRORsetFile(null,true)callfai
                    
                    flume系列之：消费Kafka集群Topic报错java.io.IOException: Can‘t resolve address: data03:9092
                        快乐骑行^_^
flumeflume系列消费Kafka集群TopicOExceptionresolveaddress
                        flume系列之：消费Kafka集群Topic报错java.io.IOException:Can'tresolveaddress:data03:9092Causedby:java.nio.channels.UnresolvedAddressException一、flume消费Kafka集群Topic报错二、报错原因三、解决方法一、flume消费Kafka集群Topic报错21Sep202214:5
                    
                    基于Spark的实时计算服务的流程架构
                        小小搬运工40
spark大数据
                        基于Spark的实时计算服务的流程架构通常涉及多个组件和步骤，从数据采集到数据处理，再到结果输出和监控。以下是一个典型的基于Spark的实时计算服务的流程架构：1.数据源数据源是实时计算服务的起点，常见的数据源包括：消息队列：如Kafka、RabbitMQ、AmazonKinesis等。日志系统：如Flume、Logstash等。传感器数据：物联网设备产生的数据流。数据库变更数据捕获（CDC）：如
                    
                    大数据开发的底层逻辑是什么？
                        瑰茵
大数据
                        大数据开发的底层逻辑主要围绕数据的生命周期进行，包括数据的采集、存储、处理、分析和可视化等环节。以下是大数据开发的一些关键底层逻辑：数据采集：目的：从不同的数据源（如日志文件、数据库、传感器等）收集数据。方法：使用数据采集工具（如ApacheFlume、ApacheKafka、ApacheSqoop）来捕获和传输数据。数据存储：目的：将收集到的数据存储在可靠且可扩展的存储系统中。方法：使用分布式文
                    
                    flume+ Elasticsearch +kibana环境搭建及讲解
                        pincharensheng
大数据flumekibanaelasticsearch分布式
                        1、软件介绍1.1、flume1.1.1、flume介绍1）flume概念1、flume是一个分布式的日志收集系统，具有高可靠、高可用、事务管理、失败重启等功能。数据处理速度快，完全可以用于生产环境；2、flume的核心是agent。agent是一个java进程，运行在日志收集端，通过agent接收日志，然后暂存起来，再发送到目的地；3、agent里面包含3个核心组件：source、channel
                    
                    Hive数据仓库中的数据导出到MySQL的数据表不成功
                        sin2201
出错问题数据仓库hivemysql
                        可能的原因：(1)没有下载flume和sqoop(2)权限问题：因为MySQL数据库拒绝了root用户从hadoop3主机的连接请求，root用户没有从hadoop3主机进行连接的权限解决：通过MySQL的授权命令来授予权限mysql>GRANTALLPRIVILEGESONsqoop_weblog.*TO'root'@'hadoop3'IDENTIFIEDBY'2020';QueryOK,0ro
                    
                    python消费kafka数据nginx日志实时_Openresty+Lua+Kafka实现日志实时采集
                        weixin_39997311

                        简介在很多数据采集场景下，Flume作为一个高性能采集日志的工具，相信大家都知道它。许多人想起Flume这个组件能联想到的大多数都是Flume跟Kafka相结合进行日志的采集，这种方案有很多他的优点，比如高性能、高吞吐、数据可靠性等。但是我们如果要求对日志进行实时的采集，这显然不是一个好的解决方案。原因如下：就目前来说，Flume能支持实时监控一个目录的数据文件，一旦对某个目录的文件采集完成，就会
                    
                    openresty+lua实现实时写kafka
                        sky@梦幻未来
大数据openrestynginxopenrestylua
                        一.背景在使用openresty+lua+nginx+flume，通过定时切分日志发送kafka的方式无法满足实时性的情况下，小编开始研究openresty+lua+nginx+kafka实时写kafka，从而达到数据实时性，和高性能保证。二.实现1.openresty安装nginx，以及lua的使用请看博主上一篇博客https://blog.csdn.net/qq_29497387/articl
                    
                    SeaTunnel 与 DataX 、Sqoop、Flume、Flink CDC 对比
                        不二人生
#数据集成工具SeaTunnel
                        文章目录SeaTunnel与DataX、Sqoop、Flume、FlinkCDC对比同类产品横向对比2.1、高可用、健壮的容错机制2.2、部署难度和运行模式2.3、支持的数据源丰富度2.4、内存资源占用2.5、数据库连接占用2.6、自动建表2.7、整库同步2.8、断点续传2.9、多引擎支持2.10、数据转换算子2.11、性能2.12、离线同步2.13、增量同步&实时同步2.14、CDC同步2.15
                    
                    flume系列之：flume落cos
                        快乐骑行^_^
日常分享专栏flume系列
                        flume系列之：flume落cos一、参考文章二、安装cosjar包三、添加hadoop-cos的相关配置四、flume环境添加hadoop类路径五、使用cos路径六、启动/重启flume一、参考文章Kafka数据通过Flume存储到HDFS或COSflumetocos使用指南二、安装cosjar包将对应hadoop版本的hadoop-cos的jar包(hadoop-cos-{hadoop.ve
                    
                    Flume 简介01 作用 核心概念 事务机制 安装 配置入门实战
                        湖中屋
Flumeflume
                        Flume1.业务系统为什么会产生用户行为日志，怎么产生的用户行文日志：每一次访问的行为（访问、搜索）产生的日志记录用户行为日志的目的：1.商家会精准的给你呈现符合你的个人界面2.商家会给你个人添加用户标签，更加精准的分析埋点等2.flume用来做什么的（采集传输数据的，分布式的，可靠的）ApacheFlume是一个从可以收集例如日志，事件等数据资源，并将这些数量庞大的数据从各项数据资源中集中起来
                    
                    大数据-257 离线数仓 - 数据质量监控 监控方法 Griffin架构
                        武子康
大数据离线数仓大数据数据仓库java后端hadoophive
                        点一下关注吧！！！非常感谢！！持续更新！！！Java篇开始了！目前开始更新MyBatis，一起深入浅出！目前已经更新到了：Hadoop（已更完）HDFS（已更完）MapReduce（已更完）Hive（已更完）Flume（已更完）Sqoop（已更完）Zookeeper（已更完）HBase（已更完）Redis（已更完）Kafka（已更完）Spark（已更完）Flink（已更完）ClickHouse（已
                    
                    kafka直接对接nginx
                        Lu_Xiao_Yue
nginxkafka
                        很多时候我们要对nginx产生的日志进行分析都是通过flume监控nginx产生的日志，通过flume把日志文件发送该kafka，flume作为生产者，但是这种方式的缺点就是可能效率会比较慢，除此之外还可以使用kafka直接对接nginx，nginx作为生产者，把log日志直接对接到kafka的某些分区中，这种方法的效率比较高，但是缺点就是可能会出现数据丢失，可以通过把nginx的日志进行一份给k
                    
                    大数据新视界 --大数据大厂之大数据实战指南：Apache Flume 数据采集的配置与优化秘籍
                        青云交
大数据新视界数据库ApacheFlume数据采集安装部署配置优化高级功能大数据工具集成
                        亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：大数
                    
                    nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
                    
                    Flume：大规模日志收集与数据传输的利器
                        傲雪凌霜，松柏长青
后端大数据flume大数据
                        Flume：大规模日志收集与数据传输的利器在大数据时代，随着各类应用的不断增长，产生了海量的日志和数据。这些数据不仅对业务的健康监控至关重要，还可以通过深入分析，帮助企业做出更好的决策。那么，如何高效地收集、传输和存储这些海量数据，成为了一项重要的挑战。今天我们将深入探讨ApacheFlume，它是如何帮助我们应对这些挑战的。一、Flume概述ApacheFlume是一个分布式、可靠、可扩展的日志
                    
                    解决flume在抽取不断产生的日志文件时，hdfs上出现很多小文件的问题
                        lzhlizihang
flumehdfs大数据
                        问题在使用flume时，需要编写conf文件，然后执行，明明sinks已经指定了roll的三个参数：a1.sinks.k1.hdfs.rollInterval=0（根据写入时间来切割）a1.sinks.k1.hdfs.rollSize=0（根据写入的文件大小来切割）a1.sinks.k1.hdfs.rollCount=0（根据Event数量来切割）其中0代表不根据其属性来切割文件但是hdfs上还会
                    
                    pyspark kafka mysql_数据平台实践①——Flume+Kafka+SparkStreaming(pyspark)
                        weixin_39793638
pysparkkafkamysql
                        蜻蜓点水Flume——数据采集如果说，爬虫是采集外部数据的常用手段的话，那么，Flume就是采集内部数据的常用手段之一(logstash也是这方面的佼佼者)。下面介绍一下Flume的基本构造。Agent：包含Source、Channel和Sink的主体，它是这3个组件的载体，是组成Flume的数据节点。Event：Flume数据传输的基本单元。Source：用来接收Event，并将Event批量传
                    
                    【大数据Big DATA】大数据解决方案，提供完整的大数据采集，大数据存储，大数据处理，具体业务应用解决方案
                        _晓夏_
JAVA大数据大数据解决方案大数据BIGDATA大数据采集大数据存储大数据处理大数据分析
                        大数据解决方案是指利用大数据技术，结合企业实际业务需求，为企业提供数据采集、存储、处理、分析和报告等一站式服务，以帮助企业更好地利用大数据提高运营效率、优化决策制定。以下是一些常见的大数据解决方案：一、数据采集数据采集是大数据解决方案的起点，涉及从各种数据源中抓取和收集数据。常见的大数据采集工具包括Flume、Scribd等，这些工具可以帮助企业快速、高效地采集各类数据。二、数据存储大数据存储解决
                    
                    大数据技术之Flume 企业开发案例——自定义 Interceptor（8）
                        大数据深度洞察
Flumeflume大数据
                        目录自定义Interceptor1）案例需求2）需求分析3）实现步骤创建一个Maven项目，并引入以下依赖。定义CustomInterceptor类并实现Interceptor接口。编辑flume配置文件分别在hadoop12，hadoop13，hadoop14上启动flume进程，注意先后顺序。在hadoop12使用netcat向localhost:44444发送字母和数字。观察hadoop13
                    
                    大数据基础之Flume——Flume基础及Flume agent配置以及自定义拦截器
                        Clozzz
Flume大数据flumehadoop
                        Flume简介Flume用于将多种来源的日志以流的方式传输至Hadoop或者其他目的地 -一种可靠、可用的高效分布式数据收集服务Flume拥有基于数据流上的简单灵活架构，支持容错、故障转移与恢复由Cloudera2009年捐赠给Apache，现为Apache顶级项目Flume架构Client：客户端，数据产生的地方，如Web服务器Event：事件，指通过Agent传输的单个数据包，如日志数据通常对
                    
                    Flume介绍及调优
                        桓桓桓桓
分布式大数据日志搜集
                        一、概述Flume是Cloudera提供的一个高可用的，高可靠的，分布式的海量日志采集、聚合和传输的系统，Flume支持在日志系统中定制各类数据发送方，用于收集数据；同时，Flume提供对数据进行简单处理，并写到各种数据接受方（可定制）的能力。当前Flume有两个版本Flume0.9X版本的统称Flume-og，Flume1.X版本的统称Flume-ng。由于Flume-ng经过重大重构，与Flu
                    
                    大数据技术之Flume 数据流监控——Ganglia 的安装与部署（11）
                        大数据深度洞察
Flume大数据flume
                        目录Flume数据流监控Ganglia的安装与部署Ganglia组件介绍1）安装Ganglia2）在hadoop12修改配置文件/etc/httpd/conf.d/ganglia.conf3）在hadoop12修改配置文件/etc/ganglia/gmetad.conf4）在hadoop12,hadoop13,hadoop14修改配置文件/etc/ganglia/gmond.conf5）在hado
                    
                                项目中 枚举与注解的结合使用
                                    飞翔的马甲
javaenumannotation
                                    前言：版本兼容，一直是迭代开发头疼的事，最近新版本加上了支持新题型，如果新创建一份问卷包含了新题型，那旧版本客户端就不支持，如果新创建的问卷不包含新题型，那么新旧客户端都支持。这里面我们通过给问卷类型枚举增加自定义注解的方式完成。顺便巩固下枚举与注解。 
 
一、枚举 
1.在创建枚举类的时候，该类已继承java.lang.Enum类，所以自定义枚举类无法继承别的类，但可以实现接口。 
 
   
                                
                                【Scala十七】Scala核心十一：下划线_的用法
                                    bit1129
scala
                                    下划线_在Scala中广泛应用，_的基本含义是作为占位符使用。_在使用时是出问题非常多的地方，本文将不断完善_的使用场景以及所表达的含义 
  1. 在高阶函数中使用 
scala> val list = List(-3,8,7,9)
list: List[Int] = List(-3, 8, 7, 9)

scala> list.filter(_ > 7)
r
                                
                                web缓存基础：术语、http报头和缓存策略
                                    dalan_123
Web
                                    对于很多人来说，去访问某一个站点，若是该站点能够提供智能化的内容缓存来提高用户体验，那么最终该站点的访问者将络绎不绝。缓存或者对之前的请求临时存储，是http协议实现中最核心的内容分发策略之一。分发路径中的组件均可以缓存内容来加速后续的请求，这是受控于对该内容所声明的缓存策略。接下来将讨web内容缓存策略的基本概念，具体包括如如何选择缓存策略以保证互联网范围内的缓存能够正确处理的您的内容，并谈论下
                                
                                crontab 问题
                                    周凡杨
linuxcrontabunix
                                      
一：  0481-079   Reached   a   symbol   that   is   not   expected.   
   
背景：  
*/5   *   *   *   *  /usr/IBMIHS/rsync.sh  
                                
                                让tomcat支持2级域名共享session
                                    g21121
session
                                    tomcat默认情况下是不支持2级域名共享session的，所有有些情况下登陆后从主域名跳转到子域名会发生链接session不相同的情况，但是只需修改几处配置就可以了。 
打开tomcat下conf下context.xml文件 
找到Context标签,修改为如下内容 
如果你的域名是www.test.com 
<Context sessionCookiePath="/path&q
                                
                                web报表工具FineReport常用函数的用法总结（数学和三角函数）
                                    老A不折腾
Webfinereport总结
                                      
ABS 
ABS(number):返回指定数字的绝对值。绝对值是指没有正负符号的数值。 
Number:需要求出绝对值的任意实数。 
示例: 
ABS(-1.5)等于1.5。 
ABS(0)等于0。 
ABS(2.5)等于2.5。 
  
ACOS 
ACOS(number):返回指定数值的反余弦值。反余弦值为一个角度，返回角度以弧度形式表示。 
Number:需要返回角
                                
                                linux 启动java进程 sh文件
                                    墙头上一根草
linuxshelljar
                                    #!/bin/bash
#初始化服务器的进程PId变量
user_pid=0;
robot_pid=0;
loadlort_pid=0;
gateway_pid=0;

#########
#检查相关服务器是否启动成功
#说明：
#使用JDK自带的JPS命令及grep命令组合，准确查找pid
#jps 加 l 参数，表示显示java的完整包路径
#使用awk，分割出pid 
                                
                                我的spring学习笔记5-如何使用ApplicationContext替换BeanFactory
                                    aijuans
Spring 3 系列
                                    如何使用ApplicationContext替换BeanFactory？ 
 
package onlyfun.caterpillar.device;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import
                                
                                Linux 内存使用方法详细解析
                                    annan211
linux内存Linux内存解析
                                    来源 http://blog.jobbole.com/45748/ 
 
 

我是一名程序员，那么我在这里以一个程序员的角度来讲解Linux内存的使用。

一提到内存管理，我们头脑中闪出的两个概念，就是虚拟内存，与物理内存。这两个概念主要来自于linux内核的支持。

Linux在内存管理上份为两级，一级是线性区，类似于00c73000-00c88000，对应于虚拟内存，它实际上不占用
                                
                                数据库的单表查询常用命令及使用方法(-)
                                    百合不是茶
oracle函数单表查询
                                      
  
创建数据库; 
      
--建表
create table bloguser(username varchar2(20),userage number(10),usersex char(2));

 
      创建bloguser表,里面有三个字段 
  
  
&nbs
                                
                                多线程基础知识
                                    bijian1013
java多线程threadjava多线程
                                    一．进程和线程 
进程就是一个在内存中独立运行的程序，有自己的地址空间。如正在运行的写字板程序就是一个进程。 
“多任务”：指操作系统能同时运行多个进程（程序）。如WINDOWS系统可以同时运行写字板程序、画图程序、WORD、Eclipse等。 
线程：是进程内部单一的一个顺序控制流。 
线程和进程 
a.       每个进程都有独立的
                                
                                fastjson简单使用实例
                                    bijian1013
fastjson
                                    一.简介 
        阿里巴巴fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库；包括“序列化”和“反序列化”两部分，它具备如下特征：     
                                
                                【RPC框架Burlap】Spring集成Burlap
                                    bit1129
spring
                                    Burlap和Hessian同属于codehaus的RPC调用框架，但是Burlap已经几年不更新，所以Spring在4.0里已经将Burlap的支持置为Deprecated,所以在选择RPC框架时，不应该考虑Burlap了。 
这篇文章还是记录下Burlap的用法吧，主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成 
 
                                
                                【Mahout一】基于Mahout 命令参数含义
                                    bit1129
Mahout
                                    1. mahout seqdirectory 
  
    $ mahout seqdirectory 
        --input (-i) input               Path to job input directory(原始文本文件).
        --output (-o) output             The directory pathna
                                
                                linux使用flock文件锁解决脚本重复执行问题
                                    ronin47
linux lock　重复执行
                                    linux的crontab命令，可以定时执行操作，最小周期是每分钟执行一次。关于crontab实现每秒执行可参考我之前的文章《linux crontab 实现每秒执行》现在有个问题，如果设定了任务每分钟执行一次，但有可能一分钟内任务并没有执行完成，这时系统会再执行任务。导致两个相同的任务在执行。 
例如：       
<?         
// 
test
.php      
                                
                                java-74-数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字
                                    bylijinnan
java
                                    

public class OcuppyMoreThanHalf {

	/**
	 * Q74 数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字
	 * two solutions:
	 * 1.O(n)
	 * see <beauty of coding>--每次删除两个不同的数字，不改变数组的特性
	 * 2.O(nlogn)
	 * 排序。中间
                                
                                linux 系统相关命令
                                    candiio
linux
                                    系统参数 
cat /proc/cpuinfo  cpu相关参数 
cat /proc/meminfo 内存相关参数 
cat /proc/loadavg 负载情况 
性能参数 
1）top 
M：按内存使用排序 
P：按CPU占用排序 
1：显示各CPU的使用情况 
k：kill进程 
o：更多排序规则 
回车：刷新数据 
2）ulimit 
ulimit -a：显示本用户的系统限制参
                                
                                [经营与资产]保持独立性和稳定性对于软件开发的重要意义
                                    comsci
软件开发
                                     
 
     一个软件的架构从诞生到成熟，中间要经过很多次的修正和改造 
 
      如果在这个过程中，外界的其它行业的资本不断的介入这种软件架构的升级过程中 
    
      那么软件开发者原有的设计思想和开发路线
                                
                                在CentOS5.5上编译OpenJDK6
                                    Cwind
linuxOpenJDK
                                    几番周折终于在自己的CentOS5.5上编译成功了OpenJDK6，将编译过程和遇到的问题作一简要记录，备查。  
0. OpenJDK介绍 
OpenJDK是Sun（现Oracle）公司发布的基于GPL许可的Java平台的实现。其优点： 
1、它的核心代码与同时期Sun（-> Oracle）的产品版基本上是一样的，血统纯正，不用担心性能问题，也基本上没什么兼容性问题；（代码上最主要的差异是
                                
                                java乱码问题
                                    dashuaifu
java乱码问题js中文乱码
                                    swfupload上传文件参数值为中文传递到后台接收中文乱码               在js中用setPostParams（{"tag" : encodeURI( document.getElementByIdx_x("filetag").value，"utf-8")}）; 
然后在servlet中String t
                                
                                cygwin很多命令显示command not found的解决办法
                                    dcj3sjt126com
cygwin
                                    cygwin很多命令显示command not found的解决办法 
  
修改cygwin.BAT文件如下 
@echo off 
D: 
set CYGWIN=tty notitle glob 
set PATH=%PATH%;d:\cygwin\bin;d:\cygwin\sbin;d:\cygwin\usr\bin;d:\cygwin\usr\sbin;d:\cygwin\us
                                
                                [介绍]从 Yii 1.1 升级
                                    dcj3sjt126com
PHPyii2
                                    2.0 版框架是完全重写的，在 1.1 和 2.0 两个版本之间存在相当多差异。因此从 1.1 版升级并不像小版本间的跨越那么简单，通过本指南你将会了解两个版本间主要的不同之处。 
如果你之前没有用过 Yii 1.1，可以跳过本章，直接从"入门篇"开始读起。 
请注意，Yii 2.0 引入了很多本章并没有涉及到的新功能。强烈建议你通读整部权威指南来了解所有新特性。这样有可能会发
                                
                                Linux SSH免登录配置总结
                                    eksliang
ssh-keygenLinux SSH免登录认证Linux SSH互信
                                    转载请出自出处：http://eksliang.iteye.com/blog/2187265 一、原理 
     我们使用ssh-keygen在ServerA上生成私钥跟公钥，将生成的公钥拷贝到远程机器ServerB上后,就可以使用ssh命令无需密码登录到另外一台机器ServerB上。 
     生成公钥与私钥有两种加密方式，第一种是
                                
                                手势滑动销毁Activity
                                    gundumw100
android
                                    老是效仿ios，做android的真悲催！ 
有需求：需要手势滑动销毁一个Activity 
怎么办尼？自己写？ 
不用~，网上先问一下百度。 
结果： 
http://blog.csdn.net/xiaanming/article/details/20934541 
 
 
首先将你需要的Activity继承SwipeBackActivity，它会在你的布局根目录新增一层SwipeBackLay
                                
                                JavaScript变换表格边框颜色
                                    ini
JavaScripthtmlWebhtml5css
                                    效果查看：http://hovertree.com/texiao/js/2.htm代码如下，保存到HTML文件也可以查看效果： 
<html>
<head>
<meta charset="utf-8">
<title>表格边框变换颜色代码-何问起</title>
</head>
<body&
                                
                                Kafka Rest : Confluent
                                    kane_xie
kafkaRESTconfluent
                                    最近拿到一个kafka rest的需求，但kafka暂时还没有提供rest api（应该是有在开发中，毕竟rest这么火），上网搜了一下，找到一个Confluent Platform，本文简单介绍一下安装。 
这里插一句，给大家推荐一个九尾搜索，原名叫谷粉SOSO，不想fanqiang谷歌的可以用这个。以前在外企用谷歌用习惯了，出来之后用度娘搜技术问题，那匹配度简直感人。 
 
 环境声明：Ubu
                                
                                Calender不是单例
                                    men4661273
单例Calender
                                             在我们使用Calender的时候，使用过Calendar.getInstance()来获取一个日期类的对象，这种方式跟单例的获取方式一样，那么它到底是不是单例呢，如果是单例的话，一个对象修改内容之后，另外一个线程中的数据不久乱套了吗？从试验以及源码中可以得出，Calendar不是单例。 
测试： 
  Calendar c1 = 
                                
                                线程内存和主内存之间联系
                                    qifeifei
java thread
                                    1， java多线程共享主内存中变量的时候，一共会经过几个阶段，    
  lock:将主内存中的变量锁定，为一个线程所独占。 
  unclock:将lock加的锁定解除，此时其它的线程可以有机会访问此变量。 
  read:将主内存中的变量值读到工作内存当中。 
  load:将read读取的值保存到工作内存中的变量副本中。 
  
                                
                                schedule和scheduleAtFixedRate
                                    tangqi609567707
javatimerschedule
                                    原文地址：http://blog.csdn.net/weidan1121/article/details/527307 
import java.util.Timer;import java.util.TimerTask;import java.util.Date; 
/** * @author vincent */public class TimerTest { 
 
                                
                                erlang 部署
                                    wudixiaotie
erlang
                                    1.如果在启动节点的时候报这个错 ： 
{"init terminating in do_boot",{'cannot load',elf_format,get_files}} 
则需要在reltool.config中加入 
{app, hipe, [{incl_cond, exclude}]}, 
  
  
2.当generate时，遇到： 
ERROR
                                
                
            
        
    


    
        
            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    
        
            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.