Ted North

Congratulations! That is incredible to have so many posts.

Yin Stadfield wrote:

Ted North wrote:"A static member can call/access only a static member of its own class" (Ganesh & Sharma, 2013, p. 488). Does this mean that a static reference can only call methods in its class or call fields in its class using the name of the class and the dot operator?

Hi Ted,

If I understand your statement correctly, I'll say this is not the case: Does this mean that a static reference can only call methods in its class or call fields in its class using the name of the class and the dot operator?
Because if it is within the class itself, you won't be needing to use the class name + dot operator. Example:

public class Example1{ public static int staticInt1 = 0; public static int staticInt2 = Example1.staticInt1; //using class name + dot operator public static int staticInt3 = staticInt1; //will also works even without using class name + dot operator }
You can't however, call an instance members from a static reference:

public class Example1{ public int instanceInt1 = 0; public static int staticInt2 = Example1.staticInt1; //will not compile public static int staticInt3 = staticInt1; //will not compile }

Interesting reply. Thank-you for thinking about this some with me. I think in your last example with source-code you meant to assign instanceInt1 to staticInt3 to show the compiler error. Also, I think you meant to assign Example1.instanceInt1 to staticInt2 to show a compiler error. I see what you meant though. I forgot about how it is a compiler error to assign a instance variable to a static variable.

In my opinion calling a static member without a reference of any kind, class reference or object reference, is outside of the scope of this question. Unless in the statement in question a 'static member' is a method that calls instance members in its own class or a different class after creating instances of the class so that the instance members can be called from a static context.

Wow, this can become confusing.

Thank-you for the help!

Regards,

Ted

Sergej Smoljanov wrote:I think this assume word access directly .
you can access static members of other class use type name and dot and name of types static member. and also you can create instance of class and access non static member of instance

Your reply is confusing to me. The last sentence on creating an instance and accessing instance members makes perfect sense to me though!

Hi All,

I am confused by this statement, "A static member can call/access only a static member of its own class" (Ganesh & Sharma, 2013, p. 488). Does this mean that a static reference can only call methods in its class or call fields in its class using the name of the class and the dot operator?

Respectfully,

Ted

Reference

Ganesh & Sharma. 2013. OCP Java SE 7 Cert Guide. Apress.

I am still not sure how fork() ends up calling ForkJoinWorkerThread.execTask() that results in compute() being called again. I think this functionality has something to do with the mysterious pushTask() method I was able to locate at grepcode.com in the openjdk version 7 of Java here: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7u40-b43/java/util/concurrent/ForkJoinWorkerThread.java#ForkJoinWorkerThread.pushTask%28java.util.concurrent.ForkJoinTask%29

However, looking at the Oracle documentation for the class ForkJoinWorkerThread there is no mention of the strange pushTask() method. Here is the URL for the Oracle API documentation on said class: http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ForkJoinWorkerThread.html

The pushTask() method does some complex bit shifting I think so it is difficult for me to understand. Does anyone have a layman's definition of what the pushTask() method does? I am thinking something along the lines of the excellent Head First Java by Sierra and Bates.

If pushTask() does not call the execTask() method what actually does? Finally, why is pushTask() shown in the Open-JDK 7 but not in the Oracle proprietary JDK?

Regards,

Ted

Ankit Garg wrote:Directly the fork() method doesn't call the compute() method, fork() submits the task to the worker pool. You can check the source code
public final ForkJoinTask<V> fork() { ((ForkJoinWorkerThread) Thread.currentThread()) .pushTask(this); return this; }
To backtrack, I think you can check ForkJoinWorkerThread.execTask method, which calls ForkJoinTask.doExec which calls RecursiveTask.exec where compute() method is called

Wow! Thank-you for the helpful reply Ankit. I can follow your logic in how compute() is called again by fork() but I am confused about how ForkJoinWorkerThread.execTask() gets called and starts the process that eventually ends with compute being called again. Does it have something to do with the pushTask() method inside the fork() method? I searched for pushTask() on DuckDuckGo and on GrepCode but could not find where this method is defined.

Thank-you for sharing GrepCode.com. That is a convenient way to see the source-code of Java itself.

Respectfully,

T

Ankit Garg wrote:

Ted North wrote:My question is: What is the fork() method doing in the program? Is it recursively calling the compute() method or is it summing up the numbers without making sure the value is not too large in the first if statement in the compute() method. That if statement is: if ( (to - from) <= N/NUM_THREADS)

Hi Ted, the fork method calls the compute method asynchronously. The recursive behaviour is defined in the compute method itself...

Thank-you for the reply Ankit. What you are saying makes sense, that fork() calls compute() again at some later time in some different thread.

Does the fork() method always asynchronously call the compute() method in every implementation of the fork() method? I am reading the API on the fork() method and the documentation does not mention the compute() method. Here is the URL to what I am typing about: http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ForkJoinTask.html#fork%28%29

Do you think there is a way to show that fork() calls compute() again someway with a System.out.println (SOP) statement?

Kind Regards,

T

Hello Campers!

Please let me start off by wishing my fellow Java-heads a very happy Towel Day! Now, to get straight to the biscuits...

I am reading the interesting and helpful book, "Oracle Certified Professional Java SE 7 Programmer Exams 1Z0-804 and 1Z0-805 - A Comprehensive OCPJP7 Certification Guide" by Ganesh and Sharma (2013). In this book there is an interesting program that illustrates how to use some classes from the java.util.concurrent.*; package. One I am trying to understand with my limited bonobos brain has to do with the "fork/join framework". I modified the code located in the Ganesh and Sharma (2013) book, referenced above, so that I could understand what the program was doing.

My question is: What is the fork() method doing in the program? Is it recursively calling the compute() method or is it summing up the numbers without making sure the value is not too large in the first if statement in the compute() method. That if statement is: if ( (to - from) <= N/NUM_THREADS)

The full program is below. I made some formatting modifications to display number values using the US locale and also to print some more debugging information such as count and note every time compute() is called. I also count every time fork() is called and then print out the totals upon program completion to verify that in fact every time fork() is called, compute() is again called from itself as a recursive method invocation.


The Code:

package sum; /* Listing 14-17 SumOfNUsingForkJoin.java Program from p.473 - Sharma and Ganesh - OCP Java SE 7 Study Guide - Apress Books */ import java.util.concurrent.*; import java.util.Locale; import java.text.NumberFormat; /* This class illustrates how we can compute sum of 1..N numbers using fork/join framework. The range of numbers are divided into half until the range can be handled by a thread. Once the range summation completes, the result gets summed up together. */ class SumOfNUsingForkJoin { static int forker = 0; static int computer = 0; static NumberFormat USA = NumberFormat.getInstance(Locale.US); private static long N = 1_000_000; // one million - we want to compute sum from 1..one million private static final int NUM_THREADS = 10; //number of threads to create for distributing effort /* This is the recursive implementation of the algorithm; inherit from RecursiveTask instead of RecursiveAction since we're returning values. */ static class RecursiveSumOfN extends RecursiveTask<Long> { long from, to; //from and to are range of values to sum-up public RecursiveSumOfN(long from, long to) { this.from = from; this.to = to; } /* The method performs fork and join to compute the sum. If the range of values can be summed by a thread (remember that we want to divide the summation task equally among NUM_THREADS) then, sum the range of numbers from...to using a simple for loop otherwise, fork the range and join the results. */ public Long compute() { long A = (to - from); long B = N/NUM_THREADS; System.out.println("A - (to - from) = " + USA.format((to - from))); System.out.println("B - N/NUM_THREADS = " + USA.format(N/NUM_THREADS)); System.out.println("Is A <= B ? Answer: " + (A <= B)); if ( (to - from) <= N/NUM_THREADS) { //the range is something that can be handled by a thread, so do summation long localSum = 0; //add in range 'from' ... 'to' inclusive of the value 'to' for (long i = from; i <= to; i++) { localSum += i; } System.out.printf("\t Summing of value range %s to %s is %s %n", USA.format(from), USA.format(to), USA.format(localSum)); return localSum; } else { /* No, the range is big for a thread to handle, so fork the computation we find the mid-point value in the range from...to */ long mid = (from + to)/2; System.out.printf("#%d Forking computation into two ranges: %s to %s and %s to %s %n", ++forker, USA.format(from), USA.format(mid), USA.format(mid + 1), USA.format(to)); //determine the computation for first half with the range from..mid RecursiveSumOfN firstHalf = new RecursiveSumOfN(from, mid); //now fork off that task firstHalf.fork(); //determine the computation for second half with the range mid+1...to RecursiveSumOfN secondHalf = new RecursiveSumOfN(mid + 1, to); long resultSecond = secondHalf.compute(); System.out.printf("#%d Calling compute() method again from inside else statement. %n", ++computer); //now, wait for the first half of computing sum to complete, once done, add it to the remaining part return firstHalf.join() + resultSecond; } } //end compute method } //end static inner class //main public static void main(String[] args) { //Create a fork-join pool that consists of NUM_THREADS ForkJoinPool pool = new ForkJoinPool(NUM_THREADS); //submit the computation task to the fork-join pool long computedSum = pool.invoke(new RecursiveSumOfN(0, N)); //this is the formula sum for the range 1...N long formulaSum = (N * (N + 1)) / 2; //Compare the computed sum and the formula sum System.out.printf("Sum for range 1...%s: COMPUTED SUM = %s FORMULA SUM = %s %n", USA.format(N), USA.format(computedSum), USA.format(formulaSum)); System.out.printf("Total number of times compute() was called: %d. Total number of times fork() was called: %d", computer, forker); } //end main } //end outer class


Thank-you for reading this post, especially on Hitchhiker's Guide to the Galaxy Day!

Respectfully,

Tedster

Jeanne Boyarsky wrote:

Ted North wrote:Do the two dots mean to move back one directory to the previous directory, which is just above the 'programs' directory? So since the path is going into the 'programs' directory then directly out of it with the double periods the normalize() method removes it?

Exactly.

Ted North wrote:For instance in a BASH shell typing: cd ../ will move back one directory. Where as cd <directory-name> moves to the typed directory.

This is even stranger because I rarely use Windows any more and the question is with a Windows file system.

Stick with that mental model. cd .. works on Windows too. Really, it does. Java tries to be platform independent so you can switch the directory path separators. Which means I could write c:/OCPJP7 and Java will be happy as a clam.

Cool. Thank-you Jeanne for helping me to understand this normalize() method. I am glad Java is platform independent. I can write once and run it everywhere.

P.S. - That was interesting to read about cd on Windows. Working with the operating-system (OS) in a shell is often times more fun than a GUI like Explorer on Windows or Nautilus on Ubuntu.

Sincerely,

Ted

Jeanne,

Thank-you for the helpful reply. I think I understand that the single dot is removed - just because it does not make a lot of sense in a path to a file but the two dots are confusing still. 0_o It is sort of surprising that the Path compiles at all with the strange dots in the middle of the URL or URI.

Do the two dots mean to move back one directory to the previous directory, which is just above the 'programs' directory? So since the path is going into the 'programs' directory then directly out of it with the double periods the normalize() method removes it?

For instance in a BASH shell typing: cd ../ will move back one directory. Where as cd <directory-name> moves to the typed directory.

This is even stranger because I rarely use Windows any more and the question is with a Windows file system.

I hope this made sense to someone other than me.

Sincerely,

Ted

Hey all,

I am still reading the G&S book thanks to enough free time, working computer, and relatively good health. Some people think C and Python are the best languages but I am continuing to venture down this binary Java programming road of mystery and wonder. Without further ado, could someone please explain to me how the normalize() method from the Path class is working in this example found on page 279 of the G&S book on passing the OCP Java 7 SE Programmer 2 exam?

Here is teh codez:

import java.nio.file.*; class SubPath { public static void main(String [] args) { Path aPath = Paths.get("D:\\OCPJP7\\programs\\..\\NIO2\\src\\.\\SubPath.java"); aPath = aPath.normalize(); System.out.println(aPath.subpath(2,3)); } } /* the answer is the program prints: src This is because apparently the normalize() method creates the following path after being called: D:\OCPJP7\NIO2\src\SubPath.java Can anyone please explain why the 'programs' directory was removed? */

Thank-you for reading Java Ranch dot com. I hope everyone is having an awesome time and living out their wildest dreams everyday.

Sincerely,

Ted

Thanks Java Ranch for helping me understand regular expressions more! I read everyone's responses and it has helped me understand in much greater detail what is happening in the IP regular expression.

I am understanding how the individual components function together as a whole now. This may not be an incredibly difficult programming syntax to decipher after all.

I see how if there is a \\d meta-symbol after the brackets this symbolizes that there should be any digit (0-9) unless said meta-symbol is followed by a question mark which means that this is optional or can appear at the most a single time. Plus the OR symbols are not as confusing as before. I do not think I understood at first that only one of these options is being chosen at a time.

Thank-you again Java Ranch. I am sure I will have more questions for the board soon.

Sincerely,

Ted

Rico Felix wrote:

Ted North wrote:What is the operator that determines if three numbers appear, two numbers, or just one since an IP could be 192.168.300.300 or 192.168.1.1 etc?

[01]?\\d\\d? is used to get one digit or two digits or three digits since two digits are optional...

Rico,

Thank-you for explaining this confusing regular expression stuff.

So with the ORs | - the expression can choose only one of these? So in this case it would either be a number starting with 25 or 2 or 0 or 1?

Also, when would the regex engine choose the zero in [01] towards the end of the regex? I have never seen an IP such as 192.168.1.01

Sincerely,

Ted

Rico Felix wrote:

Henry Wong wrote:For large regexes, it is generally a good idea to break it down to it's components.

That is exactly what you must do to make sense of long regex's...

We start with "\\b((25[0-5]|2[0-4]\\d|[01]?\\d\\d?)(\\.)){3}(25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\b" and move left to right just like the regex engine would:

Seeing that you have a fair amount of knowledge on regex's from your last post (the image), skipping over the obvious parts we decipher through the non-obvious

25[0-5] translates to 250 min to 255 max

2[0-4]\\d translates to 200 min to 249 max

[01]?\\d\\d? translates to 0 min to 199 max (remember ? mean 0 or one)

Thank you for the explanation of the numbers Rico. This really helped. I see how the \\d's represent any number from zero through nine now.

What is the operator that determines if three numbers appear, two numbers, or just one since an IP could be 192.168.300.300 or 192.168.1.1 etc?

Respectfully,

Ted