Java InterruptException类代码示例

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
public Status send(String key, Task data) {
    try {
        log.debug("Publishing Request data to Kafka. Topic:{}, Key: {}, value: {}", topic, key, data);
        kafkaProducer.send(topic, key, data).get(); // send data right now.
        log.info("Publishing SUCCESSFUL");
    } catch (InterruptException ie) {
        log.error("Publisher thread interrupted. Exception: {}. Value: {}", ie, data);
        return Status.FAILURE;
    } catch (SerializationException se) {
        log.error("Supplied object could not be published due to serialization issues. Exception: {}", se);
        return Status.FAILURE;
    } catch (Exception e) {
        log.error("Error occurred while publishing task on Kafka. Exception: {}. Key: {}. Value{}", e, key, data);
        return Status.FAILURE;
    }
    return Status.SUCCESS;
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
/**
 * Poll this MongodbSourceTask for new records.
 *
 * @return a list of source records
 * @throws InterruptException
 */
@Override
public List<SourceRecord> poll() throws InterruptException {
    List<SourceRecord> records = new ArrayList<>();
    while (!reader.isEmpty()) {
    	Document message = reader.pool();
        Struct messageStruct = getStruct(message);
        String topic = getTopic(message);
        String db = getDB(message);
        String timestamp = getTimestamp(message);
        records.add(new SourceRecord(Collections.singletonMap("mongodb", db), Collections.singletonMap(db, timestamp), topic, messageStruct.schema(), messageStruct));
        log.trace(message.toString());
    }


    return records;
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
@Override
public void activate() {
    try {
        subscribeKafkaConsumer();
    } catch (InterruptException e) {
        throwKafkaConsumerInterruptedException();
    }
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
@Override
public void deactivate() {
    try {
        shutdown();
    } catch (InterruptException e) {
        throwKafkaConsumerInterruptedException();
    }
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
@Override
public void close() {
    try {
        shutdown();
    } catch (InterruptException e) {
        throwKafkaConsumerInterruptedException();
    }
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
/**
 * Get the partition metadata for the given topic. This can be used for custom partitioning.
 *
 * @throws InterruptException If the thread is interrupted while blocked
 */
@Override
// 从Metadata中获取指定的topc分区信息
public List<PartitionInfo> partitionsFor(String topic) {
    try {
        return waitOnMetadata(topic, null, maxBlockTimeMs).cluster.partitionsForTopic(topic);
    } catch (InterruptedException e) {
        throw new InterruptException(e);
    }
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
private void close(long timeoutMs, boolean swallowException) {
    log.trace("Closing the Kafka consumer.");
    AtomicReference<Throwable> firstException = new AtomicReference<>();
    this.closed = true;
    try {
        if (coordinator != null)
            coordinator.close(Math.min(timeoutMs, requestTimeoutMs));
    } catch (Throwable t) {
        firstException.compareAndSet(null, t);
        log.error("Failed to close coordinator", t);
    }
    ClientUtils.closeQuietly(fetcher, "fetcher", firstException);
    ClientUtils.closeQuietly(interceptors, "consumer interceptors", firstException);
    ClientUtils.closeQuietly(metrics, "consumer metrics", firstException);
    ClientUtils.closeQuietly(client, "consumer network client", firstException);
    ClientUtils.closeQuietly(keyDeserializer, "consumer key deserializer", firstException);
    ClientUtils.closeQuietly(valueDeserializer, "consumer value deserializer", firstException);
    AppInfoParser.unregisterAppInfo(JMX_PREFIX, clientId);
    log.debug("The Kafka consumer has closed.");
    Throwable exception = firstException.get();
    if (exception != null && !swallowException) {
        if (exception instanceof InterruptException) {
            throw (InterruptException) exception;
        }
        throw new KafkaException("Failed to close kafka consumer", exception);
    }
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
@Test
public void testPollThrowsInterruptExceptionIfInterrupted() throws Exception {
    int rebalanceTimeoutMs = 60000;
    int sessionTimeoutMs = 30000;
    int heartbeatIntervalMs = 3000;

    final Time time = new MockTime();
    Cluster cluster = TestUtils.singletonCluster(topic, 1);
    final Node node = cluster.nodes().get(0);

    Metadata metadata = createMetadata();
    metadata.update(cluster, Collections.<String>emptySet(), time.milliseconds());

    final MockClient client = new MockClient(time, metadata);
    client.setNode(node);
    final PartitionAssignor assignor = new RoundRobinAssignor();

    final KafkaConsumer<String, String> consumer = newConsumer(time, client, metadata, assignor,
            rebalanceTimeoutMs, sessionTimeoutMs, heartbeatIntervalMs, false, 0);

    consumer.subscribe(Arrays.asList(topic), getConsumerRebalanceListener(consumer));
    prepareRebalance(client, node, assignor, Arrays.asList(tp0), null);

    consumer.poll(0);

    // interrupt the thread and call poll
    try {
        Thread.currentThread().interrupt();
        expectedException.expect(InterruptException.class);
        consumer.poll(0);
    } finally {
        // clear interrupted state again since this thread may be reused by JUnit
        Thread.interrupted();
    }
    consumer.close(0, TimeUnit.MILLISECONDS);
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
public void close() {
    if (this.producer != null) {
        synchronized (this) {
            if (this.producer != null) {
                try {
                    localLogger.info("Start to stop producer....");
                    producer.close();
                } catch (InterruptException e) {
                    localLogger.info("producer.close() error due to ", e);
                }
                offsetLogger.printOffsetMap("KafkaPublisher");
                this.producer = null;
            }
        }
    }
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
/**
 * Get the partition metadata for the give topic. This can be used for custom partitioning.
 * @throws InterruptException If the thread is interrupted while blocked
 */
@Override
public List<PartitionInfo> partitionsFor(String topic) {
    try {
        waitOnMetadata(topic, this.maxBlockTimeMs);
    } catch (InterruptedException e) {
        throw new InterruptException(e);
    }
    return this.metadata.fetch().partitionsForTopic(topic);
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
private void maybeThrowInterruptException() {
    if (Thread.interrupted()) {
        throw new InterruptException(new InterruptedException());
    }
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
/**
 * Invoking this method makes all buffered records immediately available to send (even if <code>linger.ms</code> is
 * greater than 0) and blocks on the completion of the requests associated with these records. The post-condition
 * of <code>flush()</code> is that any previously sent record will have completed (e.g. <code>Future.isDone() == true</code>).
 * A request is considered completed when it is successfully acknowledged
 * according to the <code>acks</code> configuration you have specified or else it results in an error.
 * <p>
 * Other threads can continue sending records while one thread is blocked waiting for a flush call to complete,
 * however no guarantee is made about the completion of records sent after the flush call begins.
 * <p>
 * This method can be useful when consuming from some input system and producing into Kafka. The <code>flush()</code> call
 * gives a convenient way to ensure all previously sent messages have actually completed.
 * <p>
 * This example shows how to consume from one Kafka topic and produce to another Kafka topic:
 * <pre>
 * {@code
 * for(ConsumerRecord<String, String> record: consumer.poll(100))
 *     producer.send(new ProducerRecord("my-topic", record.key(), record.value());
 * producer.flush();
 * consumer.commit();
 * }
 * </pre>
 * <p>
 * Note that the above example may drop records if the produce request fails. If we want to ensure that this does not occur
 * we need to set <code>retries=&lt;large_number&gt;</code> in our config.
 * </p>
 * <p>
 * Applications don't need to call this method for transactional producers, since the {@link #commitTransaction()} will
 * flush all buffered records before performing the commit. This ensures that all the the {@link #send(ProducerRecord)}
 * calls made since the previous {@link #beginTransaction()} are completed before the commit.
 * </p>
 *
 * @throws InterruptException If the thread is interrupted while blocked
 */
// 等待RecordAccumulator中消息发送完
@Override
public void flush() {
    log.trace("Flushing accumulated records in producer.");
    this.accumulator.beginFlush();
    this.sender.wakeup();
    try {
        this.accumulator.awaitFlushCompletion();
    } catch (InterruptedException e) {
        throw new InterruptException("Flush interrupted.", e);
    }
}
 

import org.apache.kafka.common.errors.InterruptException; //导入依赖的package包/类
/**
 * Invoking this method makes all buffered records immediately available to send (even if <code>linger.ms</code> is
 * greater than 0) and blocks on the completion of the requests associated with these records. The post-condition
 * of <code>flush()</code> is that any previously sent record will have completed (e.g. <code>Future.isDone() == true</code>).
 * A request is considered completed when it is successfully acknowledged
 * according to the <code>acks</code> configuration you have specified or else it results in an error.
 * <p>
 * Other threads can continue sending records while one thread is blocked waiting for a flush call to complete,
 * however no guarantee is made about the completion of records sent after the flush call begins.
 * <p>
 * This method can be useful when consuming from some input system and producing into Kafka. The <code>flush()</code> call
 * gives a convenient way to ensure all previously sent messages have actually completed.
 * <p>
 * This example shows how to consume from one Kafka topic and produce to another Kafka topic:
 * <pre>
 * {@code
 * for(ConsumerRecord<String, String> record: consumer.poll(100))
 *     producer.send(new ProducerRecord("my-topic", record.key(), record.value());
 * producer.flush();
 * consumer.commit();
 * }
 * </pre>
 *
 * Note that the above example may drop records if the produce request fails. If we want to ensure that this does not occur
 * we need to set <code>retries=&lt;large_number&gt;</code> in our config.
 *
 * @throws InterruptException If the thread is interrupted while blocked
 */
@Override
public void flush() {
    log.trace("Flushing accumulated records in producer.");
    this.accumulator.beginFlush();
    this.sender.wakeup();
    try {
        this.accumulator.awaitFlushCompletion();
    } catch (InterruptedException e) {
        throw new InterruptException("Flush interrupted.", e);
    }
}