3.4 新生产者配置

• 
  acks=0If set to zero then the producer will not wait for any acknowledgment
  from the server at all. The record will be immediately added to the
  socket buffer and considered sent. No guarantee can be made that the
  server has received the record in this case, and theretriesconfiguration will not take effect (as the client won't generally know
  of any failures). The offset given back for each record will always be
  set to -1.
  


• 
  acks=1This will mean the leader will
  write the record to its local log but will respond without awaiting full
  acknowledgement from all followers. In this case should the leader fail
  immediately after acknowledging the record but before the followers
  have replicated it then the record will be lost.
  


• 
  acks=allThis means the leader will wait for the full set of in-sync replicas to
  acknowledge the record. This guarantees that the record will not be
  lost as long as at least one in-sync replica remains alive. This is the
  strongest available guarantee.
  


• 
  Other settings such asacks=2are also possible, and will require the given number of acknowledgements but this is generally less useful.
  

（producer需要server接收到数据之后发出的确认接收的信号，此项配置就是指procuder需要多少个这样的确认信号。此配置实际上代表了数据备份的可用性。以下设置为常用选项：

（1）acks=0： 设置为0表示producer不需要等待任何确认收到的信息。副本将立即加到socket
 buffer并认为已经发送。没有任何保障可以保证此种情况下server已经成功接收数据，同时重试配置不会发生作用（因为客户端不知道是否失败）回
馈的offset会总是设置为-1；

（2）acks=1： 这意味着至少要等待leader已经成功将数据写入本地log，但是并没有等待所有follower是否成功写入。这种情况下，如果follower没有成功备份数据，而此时leader又挂掉，则消息会丢失。

（3）acks=all： 这意味着leader需要等待所有备份都成功写入日志，这种策略会保证只要有一个备份存活就不会丢失数据。这是最强的保证。

（4）其他的设置，例如acks=2也是可以的，这将需要给定的acks数量，但是这种策略一般很少用。）

This
setting should correspond roughly to the total memory the producer will
use, but is not a hard bound since not all memory the producer uses is
used for buffering. Some additional memory will be used for compression
(if compression is enabled) as well as for maintaining in-flight
requests.

（producer可以用来缓存数据的内存大小。如果数据产生速度大于向broker发送的速度，producer会阻塞或者抛出异常，以“block.on.buffer.full”来表明。



这项设置将和producer能够使用的总内存相关，但并不是一个硬性的限制，因为不是producer使用的所有内存都是用于缓存。一些额外的内存会用于压缩（如果引入压缩机制），同样还有一些用于维护请求。）

No attempt will be made to batch records larger than this size.

Requests sent to brokers will contain multiple batches, one for each partition with data available to be sent.

A
small batch size will make batching less common and may reduce
throughput (a batch size of zero will disable batching entirely). A very
large batch size may use memory a bit more wastefully as we will always
allocate a buffer of the specified batch size in anticipation of
additional records.

（producer将试图批处理消息记录，以减少请求次数。这将改善client与server之间的性能。这项配置控制默认的批量处理消息字节数。

不会试图处理大于这个字节数的消息字节数。

发送到brokers的请求将包含多个批量处理，其中会包含对每个partition的一个请求。

较小的批量处理数值比较少用，并且可能降低吞吐量（0则会仅用批量处理）。较大的批量处理数值将会浪费更多内存空间，这样就需要分配特定批量处理数值的内存大小。）

The
producer groups together any records that arrive in between request
transmissions into a single batched request. Normally this occurs only
under load when records arrive faster than they can be sent out. However
in some circumstances the client may want to reduce the number of
requests even under moderate load. This setting accomplishes this by
adding a small amount of artificial delay—that is, rather than
immediately sending out a record the producer will wait for up to the
given delay to allow other records to be sent so that the sends can be
batched together. This can be thought of as analogous to Nagle's
algorithm in TCP. This setting gives the upper bound on the delay for
batching: once we getbatch.sizeworth of records for a
partition it will be sent immediately regardless of this setting,
however if we have fewer than this many bytes accumulated for this
partition we will 'linger' for the specified time waiting for more
records to show up. This setting defaults to 0 (i.e. no delay). Settinglinger.ms=5,
for example, would have the effect of reducing the number of requests
sent but would add up to 5ms of latency to records sent in the absense
of load.

（producer组将会汇总任何在请求与发送之间到达的消息记录一个单独批量的请求。通常来说，这只有在记录产生速度大于发送速度的时候才能发生。然而，
在某些条件下，客户端将希望降低请求的数量，甚至降低到中等负载一下。这项设置将通过增加小的延迟来完成--即，不是立即发送一条记录，producer
将会等待给定的延迟时间以允许其他消息记录发送，这些消息记录可以批量处理。这可以认为是TCP种Nagle的算法类似。这项设置设定了批量处理的更高的
延迟边界：一旦我们获得某个partition的batch.size，他将会立即发送而不顾这项设置，然而如果我们获得消息字节数比这项设置要小的多，
我们需要“linger”特定的时间以获取更多的消息。
这个设置默认为0，即没有延迟。设定linger.ms=5，例如，将会减少请求数目，但是同时会增加5ms的延迟。）