// 同一时刻服务器只会发一条消息给消费者
channel.basicQos(1);

//开启这行 表示使用手动确认模式
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

同时改为手动确认：
// 监听队列，false表示手动返回完成状态，true表示自动
channel.basicConsume(QUEUE_NAME, false, consumer);
这样的话，消费快的消费者能得到更多的消息

Map<String, Object> arguments = new HashMap<String, Object>(16);
arguments.put("alternate-exchange", "backup");
//普通交换器和普通队列
channel.exchangeDeclare("normal", "direct", true, false, arguments);
channel.queueDeclare("q1", false, false, false, null);
channel.queueBind("q1", "normal", "r1");

//备份交换器和备份队列
channel.exchangeDeclare("backup", "fanout", true, false, null);
channel.queueDeclare("qb", false, false, false, null);
channel.queueBind("qb", "backup", "");

channel.basicPublish("normal", "", null, "abcdef".getBytes());

方法一：给队列参数上加上x-message-ttl属性，这样所有进入该队列的消息都会有统一的过期时间
Map<String, Object> arguments = new HashMap<String, Object>(16);
arguments.put("x-message-ttl", 10000);
arguments.put("x-max-priority", 10);
channel.exchangeDeclare("eee", "fanout", true, false, null);
channel.queueDeclare(QUEUE_NAME, false, false, false, arguments);
方法二：给消息上加上属性：
        AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                .expiration("20000") //表示20000ms
                .build();
        String message = "hello world";
        channel.basicPublish("eee", "", properties, message.getBytes());

Map<String, Object> arguments = new HashMap<String, Object>(16);
arguments.put("x-expires", 2000);
channel.exchangeDeclare("eee", "fanout", true, false, null);
channel.queueDeclare(QUEUE_NAME, false, false, false, arguments);

channel.exchangeDeclare("exchange.priority", "direct", true);//定义交换器
Map<String, Object> arguments = new HashMap<String, Object>(16);
// 为队列设置队列交换器
arguments.put("x-dead-letter-exchange", dlxExchangeName);
// 设置队列中的消息 ms 钟后过期
arguments.put("x-message-ttl", 10000);
arguments.put("x-max-priority", 10);args.Add("x-max-priority", 10);//定义优先级队列的最大优先级为10
channel.queueDeclare("queue.priority", true, false, false, args);//定义优先级队列
channel.queueBind("queue.priority", "exchange.priority", "priorityKey");//队列交换器绑定
AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
        .priority(8)
        .build();
var message = “testMsg8";
//发布消息
channel.BasicPublish("exchange.priority", "priorityKey", properties, message);

channel.txSelect();
try {
    channel.basicPublish("eee", "r1", true, null, "dasd12*(!@*#!".getBytes());
    channel.txCommit();
}catch (Exception e){
    System.out.println("rollback");
    channel.txRollback();
}

》同步方法：
channel.confirmSelect();   //一定要写明这句，表示将信道设置为确认模式，否则会报错：Confirms not selected
String message = "qazwsx";
channel.basicPublish("eee", "", false, null, message.getBytes());
boolean result = channel.waitForConfirms();
if(result){
    System.out.println("arrived");
}else {
    System.out.println("no way");
}
》异步方法：
channel.confirmSelect();   ////一定要写明这句，表示将信道设置为确认模式，否则confrimListener的ack/nack方法不会被调用
String message = "qazwsx";
channel.basicPublish("eee", "r1", false, null, message.getBytes());
channel.addConfirmListener(new ConfirmListener() {
    public void handleAck(long deliveryTag, boolean multiple) throws IOException {
        System.out.println("arrived");
    }
    public void handleNack(long deliveryTag, boolean multiple) throws IOException {
        System.out.println("no way");
    }
});

QueueingConsumer consumer = new QueueingConsumer(channel);

//自动确认：
channel.basicConsume(QUEUE_NAME, true, consumer);
channel.basicQos(1);
//手动确认：拉模式：只有当broker收到消费确认后，才从队列中删除这一条消息。
channel.basicConsume(QUEUE_NAME, false, consumer);
channel.basicQos(1);
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); //发出消费者确认
basicAck(deliveryTag, multiple):
第一个参数deliveryTag
    就是接受的消息的deliveryTag,可以通过delivery.getEnvelope().getDeliveryTag()获得
第二个参数 multiple
    如果为true，确认之前接受到的消息；如果为false，只确认当前消息。
    如果为true就表示连续取得多条消息才发会确认，和计算机网络的中tcp协议接受分组的累积确认十分相似，能够提高效率。

void basicAck(long deliveryTag, boolean multiple);
void basicReject(long deliveryTag, boolean requeue);
void basicNack(long deliveryTag, boolean multiple, boolean requeue);
* deliveryTag:可以看作消息的编号，它是一个64位的长整型值，最大值是9223372036854775807。
* requeue:如果requeue 参数设置为true，则RabbitMQ会重新将这条消息存入队列，以便可以发送给下一个订阅的消费者;如果requeue 参数设置为false，则RabbitMQ立即会把消息从队列中移除，而不会把它发送给新的消费者。
* BasicReject命令一次只能拒绝一条消息，如果想要批量拒绝消息，则可以使用Basic.Nack这个命令。
* multiple:在BasicAck中，multiple 参数设置为true 则表示确认deliveryTag编号之前所有已被当前消费者确认的消息。在BasicNack中，multiple 参数设置为true 则表示拒绝deliveryTag 编号之前所有未被当前消费者确认的消息。
说明:将channel.BasicReject 或者channel.BasicNack中的requeue设置为false ，可以启用"死信队列"的功能。
上述requeue，都会将消息重新存入队列发送给下一个消费者(也有可能是其它消费者)。关于requeue还有下面一种用法。可以选择是否补发给当前的consumer。
//补发消息 true退回到queue中 /false只补发给当前的consumer
channel.basicRecover(true);
    注意：RabbitMQ仅仅通过Consumer的连接中断来确认该Message并没有被正确处理。也就是说，RabbitMQ给了Consumer足够长的时间来做数据处理。如果忘记了ack，那么后果很严重。当Consumer退出时，Message会重新分发。然后RabbitMQ会占用越来越多的内存，由于RabbitMQ会长时间运行，这个“内存泄漏”是致命的。

import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.widget.ImageView;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        displaySurfaceView();
    }

    void displayImg(){
        final ImageView iv = findViewById(R.id.iv_lu);
        //1
//        iv.setImageResource(R.mipmap.wechatimg1);

        //2
//        Drawable drawable = getResources().getDrawable(R.mipmap.wechatimg1, null);
//        iv.setImageDrawable(drawable);
        //3
        Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.wechatimg1);
        iv.setImageBitmap(bitmap);
    }

    void displaySurfaceView(){
        final SurfaceView sv = findViewById(com.example.lujianyun.va.R.id.sv_lu);

        final SurfaceHolder holder = sv.getHolder();
        final Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                Canvas canvas = holder.lockCanvas();
                Bitmap bitmap = BitmapFactory.decodeResource(getResources(), com.example.lujianyun.va.R.mipmap.wechatimg1);
                canvas.drawBitmap(bitmap, 0, 0, null);
                holder.unlockCanvasAndPost(canvas);
                holder.lockCanvas(new Rect(0,0,0,0));
                holder.unlockCanvasAndPost(canvas);
            }
        });

        holder.addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(SurfaceHolder holder) {
                t.start();
            }

            @Override
            public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

            }

            @Override
            public void surfaceDestroyed(SurfaceHolder holder) {

            }
        });



    }
}

public class DrawView extends View {

    String TAG = "DrawView";
    Bitmap bitmap;
    Bitmap orginBitmap;
    boolean bitmapFinished = false;

    public DrawView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        orginBitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.wechatimg1);


    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (!bitmapFinished) { //由于onmeasure要多次调用，所以创建对象的工作只做一次，防止耗时
            int w = MeasureSpec.getSize(widthMeasureSpec);
            int h = MeasureSpec.getSize(heightMeasureSpec);
            bitmap = Bitmap.createScaledBitmap(orginBitmap, w, h, false); 
            bitmapFinished = true;
        }
        super.onMeasure(widthMeasureSpec,heightMeasureSpec);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if (bitmap != null)
            canvas.drawBitmap(bitmap, 0, 0, null);
    }

}

import android.app.Activity;
import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.os.Environment;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.example.lll.va.R;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class AudioRecorder {

    private String tag = "AudioRecorder";
    //音频输入-麦克风
    private final static int AUDIO_INPUT = MediaRecorder.AudioSource.MIC;
    //采用频率
    //44100是目前的标准，但是某些设备仍然支持22050，16000，11025
    //采样频率一般共分为22.05KHz、44.1KHz、48KHz三个等级
    private final static int AUDIO_SAMPLE_RATE = 16000;
    //声道 单声道
    private final static int AUDIO_CHANNEL = AudioFormat.CHANNEL_IN_MONO;
    //编码
    private final static int AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT;

    private byte data[];
    private boolean isRecording = false;

    private AudioRecord audioRecord = null;  // 声明 AudioRecord 对象
    private int recordBufSize = 0; // 声明recoordBufffer的大小字段
    private Button btnStart;
    private Button btnStop;

    public static void startTask2byAudioRecord(Activity activity){
        final AudioRecorder audioRecorder = new AudioRecorder();
        audioRecorder.createAudioRecord();
        audioRecorder.btnStart = activity.findViewById(R.id.btn_start_record_audio);
        audioRecorder.btnStop = activity.findViewById(R.id.btn_stop_record_audio);
        audioRecorder.btnStart.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                audioRecorder.startRecord();
            }
        });
        audioRecorder.btnStop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                audioRecorder.stopRecord();
            }
        });
    }

    public void createAudioRecord() {
        recordBufSize = AudioRecord.getMinBufferSize(AUDIO_SAMPLE_RATE,
                AUDIO_CHANNEL, AUDIO_ENCODING);  //audioRecord能接受的最小的buffer大小
        audioRecord = new AudioRecord(AUDIO_INPUT, AUDIO_SAMPLE_RATE, AUDIO_CHANNEL, AUDIO_ENCODING, recordBufSize);
        data = new byte[recordBufSize];
    }

    public void startRecord() {
        audioRecord.startRecording();
        isRecording = true;
        thread_w.start();
    }

    private String filename = Environment.getExternalStorageDirectory() + "/test";
    Thread thread_w = new Thread(new Runnable() {
        @Override
        public void run() {

            FileOutputStream os = null;

            try {
                os = new FileOutputStream(filename);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }

            if (null != os) {
                Log.d(tag, "isRecording = " + isRecording);
                while (isRecording) {
                    int read = audioRecord.read(data, 0, recordBufSize);
                    Log.d(tag, "read size = " + read);
                    // 如果读取音频数据没有出现错误，就将数据写入到文件
                    if (AudioRecord.ERROR_INVALID_OPERATION != read) {
                        try {
                            os.write(data);
                            Log.d(tag, "os writr = " + data);
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }

                try {
                    os.flush();
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    });

    public void stopRecord() {
        isRecording = false;
        audioRecord.stop();
        audioRecord.release();
//        thread_w = null;
        PcmToWavUtil util = new PcmToWavUtil(AUDIO_SAMPLE_RATE, AUDIO_CHANNEL, AUDIO_ENCODING);
        util.pcmToWav(filename, filename + ".wav");
    }
}

import android.media.AudioFormat;
import android.media.AudioRecord;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class PcmToWavUtil {

    /**
     * 缓存的音频大小
     */
    private int mBufferSize;
    /**
     * 采样率
     */
    private int mSampleRate;
    /**
     * 声道数
     */
    private int mChannel;


    /**
     * @param sampleRate sample rate、采样率
     * @param channel channel、声道
     * @param encoding Audio data format、音频格式
     */
    PcmToWavUtil(int sampleRate, int channel, int encoding) {
        this.mSampleRate = sampleRate;
        this.mChannel = channel;
        this.mBufferSize = AudioRecord.getMinBufferSize(mSampleRate, mChannel, encoding);
    }


    /**
     * pcm文件转wav文件
     *
     * @param inFilename 源文件路径
     * @param outFilename 目标文件路径
     */
    public void pcmToWav(String inFilename, String outFilename) {
        FileInputStream in;
        FileOutputStream out;
        long totalAudioLen;
        long totalDataLen;
        long longSampleRate = mSampleRate;
        int channels = mChannel == AudioFormat.CHANNEL_IN_MONO ? 1 : 2;
        long byteRate = 16 * mSampleRate * channels / 8;
        byte[] data = new byte[mBufferSize];
        try {
            in = new FileInputStream(inFilename);
            out = new FileOutputStream(outFilename);
            totalAudioLen = in.getChannel().size();
            totalDataLen = totalAudioLen + 36;

            writeWaveFileHeader(out, totalAudioLen, totalDataLen,
                    longSampleRate, channels, byteRate);
            while (in.read(data) != -1) {
                out.write(data);
            }
            in.close();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * 加入wav文件头
     */
    private void writeWaveFileHeader(FileOutputStream out, long totalAudioLen,
                                     long totalDataLen, long longSampleRate, int channels, long byteRate)
            throws IOException {
        byte[] header = new byte[44];
        // RIFF/WAVE header
        header[0] = 'R';
        header[1] = 'I';
        header[2] = 'F';
        header[3] = 'F';
        header[4] = (byte) (totalDataLen & 0xff);
        header[5] = (byte) ((totalDataLen >> 8) & 0xff);
        header[6] = (byte) ((totalDataLen >> 16) & 0xff);
        header[7] = (byte) ((totalDataLen >> 24) & 0xff);
        //WAVE
        header[8] = 'W';
        header[9] = 'A';
        header[10] = 'V';
        header[11] = 'E';
        // 'fmt ' chunk
        header[12] = 'f';
        header[13] = 'm';
        header[14] = 't';
        header[15] = ' ';
        // 4 bytes: size of 'fmt ' chunk
        header[16] = 16;
        header[17] = 0;
        header[18] = 0;
        header[19] = 0;
        // format = 1
        header[20] = 1;
        header[21] = 0;
        header[22] = (byte) channels;
        header[23] = 0;
        header[24] = (byte) (longSampleRate & 0xff);
        header[25] = (byte) ((longSampleRate >> 8) & 0xff);
        header[26] = (byte) ((longSampleRate >> 16) & 0xff);
        header[27] = (byte) ((longSampleRate >> 24) & 0xff);
        header[28] = (byte) (byteRate & 0xff);
        header[29] = (byte) ((byteRate >> 8) & 0xff);
        header[30] = (byte) ((byteRate >> 16) & 0xff);
        header[31] = (byte) ((byteRate >> 24) & 0xff);
        // block align
        header[32] = (byte) (2 * 16 / 8);
        header[33] = 0;
        // bits per sample
        header[34] = 16;
        header[35] = 0;
        //data
        header[36] = 'd';
        header[37] = 'a';
        header[38] = 't';
        header[39] = 'a';
        header[40] = (byte) (totalAudioLen & 0xff);
        header[41] = (byte) ((totalAudioLen >> 8) & 0xff);
        header[42] = (byte) ((totalAudioLen >> 16) & 0xff);
        header[43] = (byte) ((totalAudioLen >> 24) & 0xff);
        out.write(header, 0, 44);
    }
}

import android.app.Activity;
import android.content.Context;
import android.media.AudioAttributes;
import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioRecord;
import android.media.AudioTrack;
import android.media.MediaRecorder;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.example.lll.va.R;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class AudioTracker {
    private String tag = "AudioTracker";
    //采用频率
    private final static int AUDIO_SAMPLE_RATE = 16000;
    //声道 单声道
    private final static int AUDIO_CHANNEL = AudioFormat.CHANNEL_OUT_MONO;
    //编码
    private final static int AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT;
    private AudioTrack audioTrack;
    private Activity activity;
    private int buffersize;
    private byte[] data;
    private boolean isPlay = false;
    private boolean isFirstPlay = true; //用firstPlay和isPlay组合，可以完成暂停和继续播放的功能

    public static void startTask2byAudioTrack(Activity activity) {
        final AudioTracker audioTracker = new AudioTracker();
        audioTracker.activity = activity;
        Button btnPlay = activity.findViewById(R.id.btn_play_audio);
        Button btnStop = activity.findViewById(R.id.btn_stop_audio);
        Button btnPause = activity.findViewById(R.id.btn_pause_audio);
        btnPlay.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                audioTracker.startPlay();
            }
        });
        btnStop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                audioTracker.stopPlay();
            }
        });
        btnPause.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                audioTracker.pause();
            }
        });

    }

    //AudioAttributes取代了流类型的概念（例如参见AudioManager.STREAM_MUSIC或AudioManager.STREAM_ALARM），
    // 用于定义音频播放的行为。 通过允许应用程序定义，属性允许应用程序指定比在流类型中传达的信息更多的信息：


    public void initAudioTrack() {
        if (isFirstPlay) {
            buffersize = AudioTrack.getMinBufferSize(AUDIO_SAMPLE_RATE,
                    AUDIO_CHANNEL, AUDIO_ENCODING);  //audioTracker能接受的最小的buffer大小
            audioTrack = new AudioTrack(AudioAttributes.CONTENT_TYPE_MUSIC, AUDIO_SAMPLE_RATE, AUDIO_CHANNEL
                    , AudioFormat.ENCODING_PCM_16BIT, buffersize, AudioTrack.MODE_STREAM);
            data = new byte[buffersize];
        }

    }

    public void startPlay() {
        initAudioTrack();
        audioTrack.play();
        isPlay = true;
        playThread.start();

    }

    public void pause() {
        audioTrack.stop();
        isPlay = false;
        Log.d(tag, "pasue ");
    }

    public void stopPlay() {
        audioTrack.stop();
        isPlay = false;
        isFirstPlay = true;
        audioTrack.release();
        Log.d(tag, "stop ");
        is = null;
    }

    FileInputStream is = null;
    String fileName = Environment.getExternalStorageDirectory() + "/test.wav";
    Thread playThread = new Thread(new Runnable() {
        @Override
        public void run() {
            File file = new File(fileName);

            try {
                if (isFirstPlay) { //如果是首次播放（停止后再播放也算首次）则初始化流
                    is = new FileInputStream(file);
                    isFirstPlay = false;
                }
                Log.d(tag, "is = " + is);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            writeData();
        }
    });

    private void writeData() {
        if (is == null) return;
        while (isPlay) {
            try {
                int read = is.read(data);
                Log.d(tag, "read = " + read);
                if (read != 0 && read != -1) {
                    audioTrack.write(data, 0, read);
                } else {
                    stopPlay();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}