小编nic*_*sip的帖子

我正在编写一个从简单文本文件中读取一些数据的应用程序.我感兴趣的数据文件包含以下形式的行:

Mem(100) = 120
Mem(200) = 231
Mem(43) = 12
...
Mem(1293) = 12.54

所以,你可以理解,每一行的模式都是这样的

(\s)*(\t)*Mem([0-9]*) (\s,\t)*= (\s,\t)*[0-9]*(.)*[0-9]*

就像我在字符序列"Mem"之前有任意数量的空格,后跟左括号.然后,有一个数字和一个右括号.之后,在遇到'='(等于)字符之前,有任意数量的空格.然后,任意数量的空格,直到我遇到(可能)浮点数.

如何在C++正则表达式模式中表达它？我是C++中正则表达式概念的新手,所以我需要一些帮助.

谢谢

我有以下EC2设置:

1)3个m4.xlarge节点,用于3节点ZooKeeper集合和nimbus

2)我的主管的4x m4.xlarge节点.

所有机器都运行Ubuntu Linux v14,OpenJDK v1.7和Apache Storm v0.9.4.我目前在nimbus节点(仅)中拥有的storm.yaml具有以下值:

storm.home: "/opt/apache-storm-0.9.4"
storm.local.dir: "/mnt/storm"
storm.zookeeper.servers:
     - "172.31.28.73"
     - "172.31.38.251"
     - "172.31.38.252"
storm.zookeeper.port: 2181
storm.zookeeper.root: "/storm"
storm.zookeeper.session.timeout: 20000
storm.zookeeper.connection.timeout: 15000
storm.zookeeper.retry.times: 5
storm.zookeeper.retry.interval: 1000
storm.zookeeper.retry.invervalceiling.millis: 30000
storm.cluster.mode: "distributed"
storm.local.mode.zmq: false
storm.thrift.transport: "backtype.storm.security.auth.SimpleTransportPlugin"
storm.messaging.transport: "backtype.storm.messaging.netty.Context"

nimbus.host: "127.0.0.1"
nimbus.thrift.port: 6627
nimbus.thrift.max_buffer_size: 1048576
nimbus.thrift.threads: 256
nimbus.childopts: "-Xmx256m"
nimbus.task.timeout.secs: 30
nimbus.supervisor.timeout.secs: 60
nimbus.monitor.freq.secs: 10
nimbus.cleanup.inbox.freq.secs: 600
nimbus.inbox.jar.expiration.secs: 3600
nimbus.task.launch.secs: 120
nimbus.reassign: true
nimbus.file.copy.expiration.secs: 600
nimbus.topology.validator: "backtype.storm.nimbus.DefaultTopologyValidator"

ui.port: 8080
ui.childopts: "-Xmx768m"
logviewer.port: 8000
logviewer.childopts: "-Xmx256m"
logviewer.appender.name: …

早上好,我正在开发一个公开Web服务接口的java Web应用程序.为了将全局对象保留在内存中,我将以下类用作Singleton:

public class SingletonMap {
    private static final SingletonMap instance = new SingletonMap();
    private static HashMap couponMap = null;
    private static long creationTime;

    private SingletonMap() {
        creationTime = System.currentTimeMillis();
        couponMap = new HashMap();
    }

    public static synchronized SingletonMap getInstance() {
        return instance;
    }

    public static long getCreationTime() {
        return creationTime;
    }
}

我正在使用上面的类,以便为Web服务的所有线程提供相同的HashMap实例.维护SingletonMap对象的Web服务类如下:

@WebService()
public class ETL_WS {
    private String TOMCAT_TEMP_DIR;
    private final int BUFFER_SIZE = 10000000;
    private static SingletonMap couponMap;
    private static SingletonProductMap productCategoryMap;
    private String dbTable = …

我目前正在研究Apache Spark.我已经实现了一个Custom InputFormatfor Apache Hadoop,它通过TCP套接字读取键值记录.我想将此代码移植到Apache Spark并将其与hadoopRDD()函数一起使用.我的Apache Spark代码如下:

public final class SparkParallelDataLoad {

    public static void main(String[] args) {
        int iterations = 100;
        String dbNodesLocations = "";
        if(args.length < 3) {
            System.err.printf("Usage ParallelLoad <coordinator-IP> <coordinator-port> <numberOfSplits>\n");
            System.exit(1);
        }
        JobConf jobConf = new JobConf();
        jobConf.set(CustomConf.confCoordinatorIP, args[0]);
        jobConf.set(CustomConf.confCoordinatorPort, args[1]);
        jobConf.set(CustomConf.confDBNodesLocations, dbNodesLocations);

        int numOfSplits = Integer.parseInt(args[2]);

        CustomInputFormat.setCoordinatorIp(args[0]);
        CustomInputFormat.setCoordinatorPort(Integer.parseInt(args[1]));

        SparkConf sparkConf = new SparkConf().setAppName("SparkParallelDataLoad");

        JavaSparkContext sc = new JavaSparkContext(sparkConf);

        JavaPairRDD<LongWritable, Text> records = sc.hadoopRDD(jobConf, 
                CustomInputFormat.class, LongWritable.class, Text.class, 
                numOfSplits);

        JavaRDD<LabeledPoint> points = records.map(new …

亲爱的开发人员,

我正在努力改进我的Java Web服务,我正在尝试使用更精细的方法来获取Java Web Service中属性文件的目录路径.

为了使我的Java Web应用程序更易于部署在Apache Tomcat服务器上,我将以下行添加到web.xml文件中:

<env-entry>
    <env-entry-name>loggerPropertyFile</env-entry-name>
    <env-entry-type>java.lang.String</env-entry-type>
    <env-entry-value>/Some/Long/Directory/File/Path/Which/May/Change/conf/LoggerInfo.properties</env-entry-value>
</env-entry>

正如上面的xml代码描述的那样,我在本地Filesystem中的某处放置了一个Properties文件,我希望我的Web Service根据该配置初始化其logger类.您可以意识到,每次将Web服务部署到另一台服务器时,此路径都会更改.因此,我发现我可以使用$ CATALINA_BASE属性,以使环境输入路径更小.如何从我的Java Web服务代码中检索CATALINA_BASE值(如何在Linux上完成以及如何在Windows上完成)？

谢谢.

我有以下代码

Boolean flag = new Boolean(false);
flag = true;

第二行(赋值)是否会在JVM中重新创建初始对象(基本上是对new()的调用)？我问,因为我使用一个布尔对象来同步多个线程,我担心如果重新初始化发生,等待线程将看不到值的变化.

在我的应用程序中,有多个线程被赋予对前一个Boolean对象的引用.只有一个线程将对象值更改为true,其余线程等待对象的值变为true.因此,如果T1是更改值的线程,则其代码如下:

synchronized(flag) {
    flag = true;
    flag.notifyAll();
}

其余的线程(T2)将具有如下代码:

synchronized(flag) {
    while(flag == false)
        wait();
    if(flag == true) {
        //do something
    }
}

因此,问题是在赋值为true之后,其他线程(T2)是否仍然可以访问原始对象？

谢谢,尼克

我在一个C项目中工作,我创建了以下哈希表实现:

typedef struct hash_record 
{
    char* key;
    char* value;
    struct hash_record* next;
}hash_record;

typedef struct hash_bucket
{
    char* key;
    hash_record* head_record;
}hash_bucket;

typedef struct hash_table 
{
    int bucket_num;
    hash_bucket** hash_entry;
}hash_table;

int hash_init(hash_table** h_table, int bucket_num)
{
    int i;
    (*h_table) = malloc(sizeof(char)*sizeof(hash_table));

    assert((*h_table) != NULL);
    (*h_table)->hash_entry = malloc(sizeof(hash_bucket*) * bucket_num);
    assert((*h_table)->hash_entry != NULL);
    (*h_table)->bucket_num = bucket_num;
    for(i = 0; i < bucket_num; i++)
    {
        (*h_table)->hash_entry[i] = malloc(sizeof(hash_bucket));
        (*h_table)->hash_entry[i]->head_record = NULL;
        (*h_table)->hash_entry[i]->key = NULL;
    }
    return 0;
}

int hash_destroy(hash_table** h_table) …

我目前正在开展一个涉及将一个非常大的文件(大约6GB)从一个Linux服务器传输到另一个Linux服务器的项目.服务器在Debian Squeeze上运行.为了实现我的主要目标,我最初将文件的名称和大小发送到目标计算机,并创建一个空文件,用于存储我从源计算机逐步接收的数据块.我的问题是在我的服务器中创建一个6GB的文件需要太长时间.为了更清楚,我使用以下C例程来创建新文件:

void create_file(char* f_name, long long f_size) {
    char* bs, *of, *s_f_size, *count;
    if((pid = fork()) < 0) {
            perror("fork() failed.");
            return;
    }
    if(pid == 0) {
        //Call execl
        of = (char*) malloc(sizeof(char)*(strlen("of=") + strlen(f_name) + 1));
        s_f_size = (char*) malloc(sizeof(char)*32);
        sprintf(s_f_size, "%lld", file_size);
        count = (char*) malloc(sizeof(char)*(strlen("count=") + strlen(s_f_size) + 1));
        strcpy(of, "of=");
        strcat(of, f_name);
        strcpy(count, "count=");
        strcat(count, s_f_size);
        ret = execl("/bin/dd", "dd", "if=/dev/zero", of, "bs=1", count, (char*) 0);
        if(ret < 0) {
            perror("execl() failed");
            free(s_f_size);
            free(of);
            free(count); …