Often handwritten code
1. Thread deadlock case
public class DeadLock {
public static void main(String[] args) {
Person person1 = new Person(0."Zhang");
Person person2 = new Person(1."Bill"); person1.start(); person2.start(); }}/** ** spoon */
class Spoon{}/** ** fork */
class Fork{}/ * * * * /
class Person extends Thread{
static Spoon spoon = new Spoon();
static Fork fork = new Fork();
int choice;
String personName;
public Person(int choice,String personName){
this.choice = choice;
this.personName = personName;
}
@Override
public void run(a) {
try {
eat();
} catch(InterruptedException e) { e.printStackTrace(); }}public void eat(a) throws InterruptedException {
if (choice == 0) {synchronized (spoon){
System.out.println(this.personName + "Got the spoon.");
Thread.sleep(1000);
synchronized (fork){
System.out.println(this.personName + "Got a fork."); }}}else{
synchronized (fork){
System.out.println(this.personName + "Got a fork.");
Thread.sleep(1000);
synchronized (spoon){
System.out.println(this.personName + "Got the spoon.");
}
}
}
}
}
Copy the codeExamples of static proxies
/** * static proxy: marriage case */
public class StaticProxy {
public static void main(String[] args) {
WeddingCompany weddingCompany = new WeddingCompany(newYou()); weddingCompany.happyMarry(); }}/ / to get married
interface Marry {
void happyMarry(a);
}
// True character: You get married
class You implements Marry {
@Override
public void happyMarry(a) {
System.out.println("Doris is so happy to get married."); }}// Proxy role: help you get married
class WeddingCompany implements Marry {
private Marry target;// Agent --> Real target character character, help who get married
public WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void happyMarry(a) {
after();
this.target.happyMarry();
before();
}
private void after(a) {
System.out.println("Before you get married, set the scene.");
}
private void before(a) {
System.out.println("After the wedding, the closing money."); }}Copy the code3. Simple mode for RabbitMQ
- producers
public class Producer {
// Define a queue name
public static final String QUEUE_NAME = "hello";
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168. XXX. XXX");
factory.setUsername("XXXX");
factory.setPassword("XXXX");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare(QUEUE_NAME,false.false.false.null);
String message = "hello world";
channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
System.out.println("Message sent complete"); }}Copy the code- consumers
public class Consumer {
public static final String QUEUE_NAME = "hello";
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168. XXX. XXX");
factory.setUsername("XXXX");
factory.setPassword("XXXX");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
System.out.println("Waiting to receive a message...");
DeliverCallback deliverCallback = (consumerTag,message)->{
String mes = new String(message.getBody());
System.out.println("The message received is" + mes);
};
CancelCallback cancelCallback = (String consumerTag)->{
System.out.println("Message cut off...");
};
channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback); }}Copy the code4. Work Queue for RabbitMQ
- Utility class
public class RabbitMqUtil{
public static Channel getChannel(a) throws IOException, TimeoutException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.200.130");
factory.setUsername("admin");
factory.setPassword("123");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
returnchannel; }}Copy the code- producers
public class Task01 {
private static final String QUEUE_NAME = "work";
public static void main(String[] args) throws Exception {
try (Channel channel = RabbitMqUtil.getChannel();) {
channel.queueDeclare(QUEUE_NAME, false.false.false.null);
// Receive information from the console
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String message = scanner.next();
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println("Sending message completed :"+ message); }}}}Copy the code- consumers
public class Worker01 {
public static final String QUEUE_NAME = "work";
public static void main(String[] args) throws IOException, TimeoutException {
Channel channel = RabbitMqUtil.getChannel();
DeliverCallback deliverCallback = (consumerTag,message)->{
String mes = new String(message.getBody());
System.out.println("The message received is" + mes);
System.out.println("Output complete");
};
CancelCallback cancelCallback = (consumerTag)->{
System.out.println("Output error");
};
System.out.println("C2 waiting to receive message");
channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback); }}Copy the code5. RabbitMQ message reply
Normally RabbitMQ sends a message to the consumer and deletes it, but if the consumer hangs up, the message is lost.
RabbitMQ then introduces a message reply mechanism, which does not delete the RabbitMQ message after it is sent to the consumer, but waits for the consumer to receive and process the message and then reply to RabbitMQ to say that the message can be deleted so that the message is not lost.
Generally, manual answer is used.
- Consumer 1
public class Worker03 {
public static final String TASK_QUEUE_NAME = "ack_queue";
// Receive the message
public static void main(String[] args) throws IOException, TimeoutException {
Channel channel = RabbitMqUtil.getChannel();
System.out.println("C1 is waiting for receiving message processing, and the time is relatively short");
DeliverCallback deliverCallback = (consumerTag,message)->{
SleepUtils.sleep(1);
System.out.println("The message received is" + new String(message.getBody(),"UTF-8"));
channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
};
// Use manual reply
boolean autoAck = false; channel.basicConsume(TASK_QUEUE_NAME,autoAck,deliverCallback,(consumerTag -> {})); }}Copy the code- Consumer 2
public class Worker04 {
public static final String TASK_QUEUE_NAME = "ack_queue";
// Receive the message
public static void main(String[] args) throws IOException, TimeoutException {
Channel channel = RabbitMqUtil.getChannel();
System.out.println("C2 waits for receiving message processing for a short time");
DeliverCallback deliverCallback = (consumerTag,message)->{
SleepUtils.sleep(30);
System.out.println("The message received is" + new String(message.getBody(),"UTF-8"));
channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
};
// Use manual reply
boolean autoAck = false; channel.basicConsume(TASK_QUEUE_NAME,autoAck,deliverCallback,(consumerTag -> {})); }}Copy the code- producers
public class Task02 {
// New queue name
public static final String TASK_QUEUE_NAME = "ack_queue";
// Send a message
public static void main(String[] args) throws IOException, TimeoutException {
Channel channel = RabbitMqUtil.getChannel();
channel.queueDeclare(TASK_QUEUE_NAME,false.false.false.null);
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()){
String message = scanner.next();
channel.basicPublish("",TASK_QUEUE_NAME,null,message.getBytes("UTF-8"));
System.out.println("Producer sends message :"+ message); }}}Copy the code6. Unfair reception of RabbitMQ
- Producer: Same code as in the previous case
- Consumer: Just add two lines to the code
int prefetchCount = 1;
channel.basicQos(prefetchCount);
Copy the codeActual code :(two similar, write only one)
public class Worker04 {
public static final String TASK_QUEUE_NAME = "ack_queue";
public static void main(String[] args) throws IOException, TimeoutException {
Channel channel = RabbitMqUtil.getChannel();
System.out.println("C4 waiting for receiving message processing time is long");
DeliverCallback deliverCallback = (consumerTag,message)->{
String mes = new String(message.getBody(),"UTF-8");
SleepUtils.sleep(15);
System.out.println("Message received" + mes);
channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
};
int prefetchCount = 1;
channel.basicQos(prefetchCount);
boolean autoAck = false; channel.basicConsume(TASK_QUEUE_NAME,autoAck,deliverCallback,(consumerTag -> {})); }}Copy the code