try {
    channel.txSelect();
    channel.basicPublish(exchange, routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, msg.getBytes());
    channel.txCommit();
} catch (Exception e) {
    channel.txRollback();
}

public class MessageConfirmCallback implements ConfirmCallback {
  private static final Logger LOG = LoggerFactory.getLogger(MessageConfirmCallback.class);
  @Override
  public void confirm(CorrelationData correlationData, boolean ack) {
    if (ack) {
      // 如果发送到交换器成功，但是没有匹配的队列（比如说取消了绑定），ack 返回值为还是 true（这是一个坑，需要注意）, 这种情况一般需要在returnCallBack中重新投递
             LOG.info("消息确认成功");
     } else {
      // 如果发送到交换器都没有成功（比如说删除了交换器），ack 返回值为 false
      // 处理丢失的消息（nack）
             LOG.warn("消息确认失败");
     }
  }
}

public class MessageReturnCallback implements ReturnCallback {
  private static final Logger LOG = LoggerFactory.getLogger(MessageReturnCallback.class);
  private static Charset charset = Charset.forName("UTF-8");
  @Autowired
  private RabbitTemplate rabbitTemplate;
  private JsonParser jsonParser;
  @Override
  public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
    String messageContent = new String(message.getBody(), charset);
    LOG.warn(
        "Return message from exchange {} and routing {}, reply-code is {}, reply-text is {}, message content is {}",
        exchange, routingKey, replyCode, replyCode, messageContent);
    Map<String, Object> map = jsonParser.toMap(messageContent);
    String correlationId = (String) map.get("id");
    if (null == correlationId) {
      rabbitTemplate.convertAndSend(exchange, routingKey, message);
    } else {
      CorrelationData correlationData = new CorrelationData(correlationId);
      rabbitTemplate.convertAndSend(exchange, routingKey, message, correlationData);
    }
    LOG.info("retry send message {} to exchange {} succeed.", messageContent, exchange);
  }
}

public enum State {
        /**
         * 线程刚创建，还未start
         */
        NEW,
        /**
         * 线程正在jvm中执行，对操作系统来说可能正在等待时间片执行(就绪态)
         * I/O阻塞或网络等待，对应的JVM线程状态也是RUNNABLE
         */
        RUNNABLE,
        /**
         * 程正在等待获取锁，阻塞状态
         */
        BLOCKED,
        /**
         * 一般通过Object.wait()或者Thread.join()，进入waiting状态;前提是这个线程已经拥有锁了
         * 如果一个线程调用了一个对象的wait方法，那么这个线程就会处于waiting状态直到另外一个线程调用这个对                          
         * 象的notify或者notifyAll方法后才会解除这个状态
         */
        WAITING,
        /**
         * 通过sleep(timeout)或wait(timeout)方法进入的限期等待的状态
         * 需要注意2者区别
         */
        TIMED_WAITING,
        /**
         * 线程执行结束
         */
        TERMINATED;
    }

public synchronized void start() {
        // threadStatus=0,表示当前为NEW状态
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
  
        group.add(this);
        boolean started = false;
        try {
           // 本地方法执行线程
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

public class testBlockedSocketState {
  public static void main(String[] args) throws InterruptedException {
    Thread serverThread = new Thread(new Runnable() {
      @Override
      public void run() {
        ServerSocket serverSocket = null;
        try {
          serverSocket = new ServerSocket(10086);
          while (true) {
            // 阻塞的accept方法
            Socket socket = serverSocket.accept();
          }
        } catch (IOException e) {
          e.printStackTrace();
        } finally {
          try {
            serverSocket.close();
          } catch (IOException e) {
            e.printStackTrace();
          }
        }
      }
    }, "socket线程"); // 线程的名字
    serverThread.start();
    // 确保run已经得到执行
    Thread.sleep(500);
    // 状态为RUNNABLE
    System.out.println(serverThread.getState());
  }

LoadingCache<String, String> cache = CacheBuilder.newBuilder()
        .maximumSize(1000) // 设置最大大小
        .expireAfterWrite(10, TimeUnit.MINUTES) // 设置过期时间， 10分钟
        .build(
            new CacheLoader<String, String>() {
                // 加载缓存内容
                public String load(String key) throws Exception {
                    return getFromDB(key);
                }
        });