Java simulates the sending and callback of asynchronous messages

http://kt8668.iteye.com/blog/205739

The purpose of this article is not to introduce what technology to use, but to focus on its implementation principles.

One, asynchronous and synchronous

Speaking of the popular point, asynchronous is not necessary to wait for the current execution of the completion of the action, you can continue to perform the subsequent actions.

Typically, the order in which a program executes is: From top to bottom, execution in turn. The subsequent action must wait for the previous action to complete before executing. This is a concept that is relative to asynchrony-synchronous.

Case:

A, Zhang San call John Doe, let John Doe help write a material.

B, John Doe received the phone when the hand has his own work to deal with, but he promised Zhang San, busy hand after work immediately help Zhang San write good material, and fax to Zhang San.

C, after the phone, Zhang San out of office.

Description

Zhang San to Lee four through the telephone, went out to work, he does not need to wait for John Doe to write the material well before going out. Then the message that Zhang San let John Doe write material belongs to the asynchronous message.

On the contrary, if the Zhang San must wait for John Doe to write the material in order to go out to work, then this message belongs to the synchronization message.

Second, the realization of asynchronous

Traditional program execution code is executed from top to bottom, one at a line.

But there are many things in life is not so, in the above case, if John Doe need a few hours later to help Zhang San write good material, the three must wait a few hours, so Zhang San may collapse or crazy.

Such a dragon-like treatment, the display is not very reasonable.

You can use the following methods to handle this problem:

Zhang San find Harry to John Doe call, wait for Li four write good material, from Harry to Zhang San. So Zhang San can go out and do other things.

The problem has been resolved reasonably, before Zhang 31 line of work, by Zhang San and Wang 52 line to complete, both sides at the same time, do not delay each other.

Third, the realization of computer language

How to use the program to simulate the implementation?

A, work that was previously handled by a thread can be asynchronous by adding a new thread. This is the multithreading technique in Java.

B, the last John Doe written material must be handed to Zhang San, to do his use. This is the callback.

Callback you can understand this:

A send a message to B,b to handle a required thing, the result is returned to a,a and then the result of B returned to do further processing.

Iv. implementation of Java code

A, implementation of callbacks

Java code

1. /**
2. * Callback Interface
3. * @author Kook
4. *
5. */
6. Public interface CallBack {
7. /**
8. * Execute callback method
9. * @param objects returns the processed result as a parameter to the callback method
10. */
11. public void Execute (Object ... objects);
12. }

Java is an object-oriented language, so the callback function becomes the callback interface.

B, sender of the message

Java Code

2. /**
4. * Simple class for sending asynchronous messages locally
6. * @author Kook
8. *
10. */
12. public class Local implements callback,runnable{
16. /**
18. * The class that receives the message remotely, simulates point-to-point
20. */
22. private remote remote;
26. /**
28. * Send out the message
30. */
32. Private String message;
36. Public Local (remote remote, String message) {
38. Super ();
40. This.remote = remote;
42. this.message = message;
44. }
48. /**
50. * Send Message
52. */
54. public void SendMessage ()
56. {
58. /** the name of the current thread **/
60. System.out.println (Thread.CurrentThread (). GetName ());
62. /** Create a new thread to send the message **/
64. Thread thread = new thread (this);
66. Thread.Start ();
68. /** The current thread continues execution **/
70. System.out.println ("Message had been sent by local~!");
72. }
76. /**
78. * Callback function after message is sent
80. */
82. public void Execute (Object ... objects) {
84. /** prints the returned message **/
86. System.out.println (Objects[0]);
88. /** Print the thread name of the sending message **/
90. System.out.println (Thread.CurrentThread (). GetName ());
92. /** interrupts the thread that sent the message **/
94. Thread.interrupted ();
96. }
100. public static void Main (string[] args)
102. {
104. Local local = new local (new Remote (), "Hello");
108. Local.sendmessage ();
110. }
114. public void Run () {
116. Remote.executemessage (message, this);
120. }
122. }

C, recipients of remote messages

Java Code

2. /**
4. * Remote class for processing messages
6. * @author Kook
8. *
10. */
12. public class Remote {
16. /**
18. * Processing messages
20. * Messages received by @param msg
22. * @param callBack callback function processing class
24. */
26. public void ExecuteMessage (String msg,callback CallBack)
28. {
30. /** analog remote classes are dealing with other things that may take a lot of time **/
32. for (int i=0;i<1000000000;i++)
34. {
38. }
40. /** deal with other things, now to deal with the message **/
42. SYSTEM.OUT.PRINTLN (msg);
44. System.out.println ("I Hava executed the message by Local");
46. /** Execution Callback **/
48. Callback.execute (New string[]{"Nice to meet you~!"});
50. }
54. }

Executes the main method of the Local class.

Note The row for the red background in the Local class:

Remote.executemessage (Message, this);

The ExecuteMessage method needs to receive a message parameter, which means that the messages are sent out, while the callback parameter is himself, that is, this. Indicates that the message is sent, handled by the Local class itself, and calls its own Execute method to process the message result.

If this is not used here, but with other implementations of the callback interface, then it can not be called "callback", in the OO world, it belongs to "delegation". Other words "Callback" must be the sender of the message to process the result of the message, otherwise it cannot be called a callback。 The concept must be clear.

Java simulates the sending and callback of asynchronous messages