Hadoop Source Learning Notes (3)--first glance datanode and learning threads

Hadoop Source Learning Notes (3)

--first glance datanode and learning threads

into the main function, we went out the first step, and then we look at how to go:

2. Public class DataNode extends configured implements Interdatanodeprotocol,
4. Clientdatanodeprotocol, fsconstants, Runnable {
8. Public Static DataNode Createdatanode (String args[], Configuration conf)
10. throws IOException {
12. DataNode DN = Instantiatedatanode (args, conf);
14. Rundatanodedaemon (DN);
16. return DN;
18. }
22. Public Static void Rundatanodedaemon (DataNode dn) throws IOException {
24. Dn.datanodethread = new Thread (DN, dnthreadname);
26. Dn.dataNodeThread.setDaemon (true);
28. Dn.dataNodeThread.start ();
30. }
32. }
36. Public Static DataNode Instantiatedatanode (String args[], Configuration conf)
38. throws IOException {
40. return makeinstance (datadirs, conf);
42. }
46. Public Static DataNode makeinstance (string[] datadirs, Configuration conf) {
48. return New DataNode (conf, dirs);
50. }
54. DataNode (Configuration conf, abstractlist<file> datadirs)
56. throws IOException {
58. Startdatanode (conf, datadirs);
60. }
62. Vid join () {
64. Datanodethread.join ();
66. }
70. void Startdatanode (Configuration conf, abstractlist<file> datadirs)
72. throws IOException {
74. }
78. Public Static void Main (String args[]) {
80. DataNode DataNode = Createdatanode (args, null);
82. Datanode.join ();
84. }
86. }

As you can see from the program above, the program runs from the main function and creates a Datanode object on the first layer, then creates a thread in the Rundatanodedaemon function, and then the program calls the thread to stay where it is.

In other words, it may seem clearer:

1. Public Static void Main (String args[]) {
2. DataNode DataNode = new DataNode ();
3. Thread datanodethread = new thread (DN, dnthreadname);
4. Datanodethread.setdaemon (true);
5. Datanodethread.start ();
6. Datanodethread.join ();
7. }

So the code is clear, in other words, the whole datanode now looks like a big thread running.

For the whole thread, it is easier to understand that the entire class inherits from the Runnable interface and then implements the run function. Can pass through the object implementation when the thread class is created, after start, the thread runs and executes the contents of the run function.

But there are a few lines of confusion in this code:

1. Setdaemon (true): The meaning of this function is not simply literal (Daemon: Guardian), generally, when a thread has not finished running, the main program is stuck, but when set to Daemon is true, when the main program ends, the thread ends automatically.
2. Join (): This function is to wait for the thread to end and then go down. is equivalent to the same while (true) {} that we often write in the main sequence.

To create a thread, in addition to this inherited runnable interface, you can directly inherit the thread class and then call the object's start function directly. However, this is not convenient, because a class can inherit only one class, but can inherit multiple interfaces, so the interface is more flexible.

For these two features of the thread, we can write a simple example to experiment with:

2. import java.io.IOException;
6. Public class ThreadTest extends Thread {
10. Public class Firstthread extends thread{
14. @Override
16. Public void Run () {
20. }
22. }
26. Public class Secondthread implements runnable{
30. @Override
32. Public void Run () {
36. }
38. }
42. Public void Run () {
44. for (int i = 1; i <=; i++) {
46. Try {
48. Thread.Sleep (100);
50. } catch (Interruptedexception ex) {
52. Ex.printstacktrace ();
54. }
56. System.out.println (i);
58. }
60. }
64. Public Static void Main (string[] args) throws IOException {
66. ThreadTest test = new threadtest ();
68. Thread THD = new thread (test);
72. //Create and start 2mehtod
74. //1:firstthread THD = new Firstthread ();
76. //THD. Start ();
80. //2:secondthread THDX = new Secondthread ()
82. //thread THD = new Thread (THD);
84. //THD. Start ();
88. //If daemon is not set, the thread will output 50 before it ends
90. Thd.setdaemon (true);
92. Thd.start ();
94. System.out.println ("Isdaemon = " + Thd.isdaemon ());
96. System.in.read (); //Accept Input program at this pause, once there is input, main thread ends, daemon thread ends automatically
98. //thd.join ();
100. }
102. }

The example involves creating a threading method, a join function, and a setdaemno function that can be released separately to debug and observe.

Hadoop Source Learning Notes (3)--first glance datanode and learning threads