小编cod*_*erz的帖子

在Rails中,find_each和where用于从ActiveRecord支持的数据库中检索数据.

您可以将查询条件传递给where,例如:

c = Category.where(:name => 'Ruby', :position => 1)

您可以将批量大小传递给find_each,例如:

Hedgehog.find_each(batch_size: 50).map{ |p| p.to_json }

但是以下两个代码有什么区别？

# code 1
Person.where("age > 21").find_each(batch_size: 50) do |person|
  # processing
end

# code 2
Person.where("age > 21").each do |person|
  # processing
end

代码1批次每次检索50个元组,代码2一次检索所有元组吗？欢迎更多细节解释.

我的意见是:

1. 既where和find_each可用于批量检索,但是用户可使用时限定批量大小find_each.
2. find_each 不支持传递查询条件.

如果我的理解是错误的,请纠正我.

要创建MapReduce作业,您可以使用旧org.apache.hadoop.mapred包或org.apache.hadoop.mapreduceMapper和Reducers,Jobs ... 的新包.第一个已被标记为已弃用但同时也已恢复.现在我想知道使用旧的mapred包或新的mapreduce包来创建作业以及为什么更好.或者它只取决于您是否需要像旧的mapred包中可用的MultipleTextOutputFormat之类的东西？

我有一个使用JVM ARGS的Java 7应用程序:-Xms1024m -Xmx2048m它运行得很好.

升级到Java 8后,它以错误状态运行,并显示异常:

Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
    at org.hibernate.engine.StatefulPersistenceContext.addEntry(StatefulPersistenceContext.java:466)
    at org.hibernate.engine.TwoPhaseLoad.postHydrate(TwoPhaseLoad.java:80)
    at org.hibernate.loader.Loader.loadFromResultSet(Loader.java:1439)
    at org.hibernate.loader.Loader.instanceNotYetLoaded(Loader.java:1332)
    at org.hibernate.loader.Loader.getRow(Loader.java:1230)
    at org.hibernate.loader.Loader.getRowFromResultSet(Loader.java:603)
    at org.hibernate.loader.Loader.doQuery(Loader.java:724)
    at org.hibernate.loader.Loader.doQueryAndInitializeNonLazyCollections(Loader.java:259)
    at org.hibernate.loader.Loader.doList(Loader.java:2228)
    at org.hibernate.loader.Loader.listIgnoreQueryCache(Loader.java:2125)
    at org.hibernate.loader.Loader.list(Loader.java:2120)
    at org.hibernate.loader.criteria.CriteriaLoader.list(CriteriaLoader.java:118)
    at org.hibernate.impl.SessionImpl.list(SessionImpl.java:1596)
    at org.hibernate.impl.CriteriaImpl.list(CriteriaImpl.java:306)

我想知道JVM ARGS -Xms1024m -Xmx2048m是否还在工作？

由于Java 8已经删除了Perm Generation:http://www.infoq.com/articles/Java-PERMGEN-Removed,我认为Java 7和Java 8之间的不同GC策略/内存管理可能是根本原因.有什么建议吗？

我找不到提交不使用已弃用JobConf类的Hadoop作业的单个示例. JobClient,尚未弃用,仍然只支持带JobConf参数的方法.

有人可以指点我的Java代码提交Hadoop地图/减少作业只使用Configuration类(非JobConf),并使用mapreduce.lib.input包而不是mapred.input？

嗨,我想知道jobconf和job对象之间的基本区别,目前我正在提交我的工作

JobClient.runJob(jobconf);

我看到了提交这样的工作的其他方式

Configuration conf = getConf();
Job job = new Job(conf, "secondary sort");
job.waitForCompletion(true);     
return 0;

如何使用jobconf为作业指定sortcomparator类？

任何人都可以向我解释这个概念吗？

CyclicBarrier/ CountDownLatch和joinJava 之间的区别是什么？有什么优势CyclicBarrier和CountDownLatch？在我看来,只需使用join我们就可以等待一个线程完成它的执行.

在Java,没有线程安全版本的HashMap命名的ConcurrentHashMap和线程安全版本TreeMap的命名ConcurrentSkipListMap,但没有ConcurrentHashSet对HashSet的.

相反,通常有4种方法可以使用线程安全Set:

1. Set<String> mySet = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>());
2. Set<String> s = Collections.synchronizedSet(new HashSet<String>());
3. ConcurrentSkipListSet<E>
4. CopyOnWriteArraySet<E>

1所使用keySet()的ConcurrentHashMap同时实现Set和线程安全的.

2使用synchronized方式,似乎不推荐这种方式.

图3基于ConcurrentSkipListMap并被广泛使用.

4基于CopyOnWriteArrayList,因此它共享相同的基本属性CopyOnWriteArrayList.以下是从CopyOnWriteArraySetdoc中选择:http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CopyOnWriteArraySet.html

• 它最适合于设置大小通常很小的应用程序,只读操作数量远远超过可变操作,并且您需要在遍历期间防止线程之间的干扰.
• 它是线程安全的.
• 变异操作(添加,设置,删除等)很昂贵,因为它们通常需要复制整个底层阵列.
• 迭代器不支持mutative remove操作.
• 遍历迭代器的速度很快,不会遇到来自其他线程的干扰.
• 迭代器在构造迭代器时依赖于不变的数组快照.

由于常用1和3,为什么CopyOnWriteArraySet存在？什么时候CopyOnWriteArraySet有用？

补充: CopyOnWriteArraySet基于CopyOnWriteArrayList,并且数据结构中的contains操作List是O(n),而Set数据结构是为了高性能contains操作,有人可以解释一下吗？

我有使用Java8的代码:

List<Integer> list = new ArrayList<Integer>();
list.add(3);
list.add(5);
list.add(4);
list.add(2);
list.add(5);
list = list.stream().filter(i -> i >= 3).collect(Collectors.toList());

原始列表是[3,5,4,2,5].在"过滤"和"收集"操作之后,列表变为[3,5,4,5].

是否所有操作都在原始列表中执行,并且不创建新列表？或者在"过滤"和"收集"操作之后,返回一个新创建的列表并忽略原始列表？

当我尝试索引数据然后进行查询时,一切都很好,但如果我启动我的应用程序并将在没有索引的情况下进行查询之前我得到了该错误

Exception in thread "main" org.elasticsearch.action.search.SearchPhaseExecutionException: Failed to execute phase [query_fetch], all shards failed at org.elasticsearch.action.search.type.TransportSearchTypeAction$BaseAsyncAction.onFirstPhaseResult(TransportSearchTypeAction.java:272)
    at org.elasticsearch.action.search.type.TransportSearchTypeAction$BaseAsyncAction$3.onFailure(TransportSearchTypeAction.java:224)
    at org.elasticsearch.search.action.SearchServiceTransportAction.sendExecuteFetch(SearchServiceTransportAction.java:307)
    at org.elasticsearch.action.search.type.TransportSearchQueryAndFetchAction$AsyncAction.sendExecuteFirstPhase(TransportSearchQueryAndFetchAction.java:71)
    at org.elasticsearch.action.search.type.TransportSearchTypeAction$BaseAsyncAction.performFirstPhase(TransportSearchTypeAction.java:216)
    at org.elasticsearch.action.search.type.TransportSearchTypeAction$BaseAsyncAction.performFirstPhase(TransportSearchTypeAction.java:203)
    at org.elasticsearch.action.search.type.TransportSearchTypeAction$BaseAsyncAction$2.run(TransportSearchTypeAction.java:186)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:745)

这是我的弹性搜索的代码和设置

    //  settings
    ImmutableSettings.Builder settings = ImmutableSettings.settingsBuilder();
    settings.put("client.transport.sniff", false);
    settings.put("path.home", "/path/to/elastic/home");
    settings.put("index.number_of_replicas", 0);
    settings.put("index.number_of_shards", 1);
    settings.put("action.write_consistency", "one");

    settings.build();
    // creating of node and client
    NodeBuilder nb = new NodeBuilder().settings(settings).local(true).data(true);
    Node node = nb.node();
    Client client = node.client();


    /*
         for (int i = 0; i <= 15; …

我想设计一个作业调度程序集群,它包含几个要执行cron作业调度的主机.例如,需要的作业run every 5 minutes被提交到集群,集群应该指出下次运行要触发的主机,确保:

1. 容灾:如果不是所有主机都关闭,则应该成功触发作业.
2. 有效性:只有一个主机可以解雇下一个工作.

由于容灾,作业无法绑定到特定主机.一种方法是所有主机轮询数据库表(当然有锁),这保证只有一个主机获得下一个作业运行.由于它经常锁表,有没有更好的设计？