Core Java Test 6

The interrupted() method in Java is used to check if the current thread has been interrupted or not. When the interrupted() method is called, it clears the interrupted status of the thread and returns true if it was interrupted, otherwise false. If the interrupted() method is called twice on the same thread object, the second call will always return false because the interrupted status has already been cleared by the first call.

Thread.currentThread().getName() return name of the current thread.

To invoke the run() method on a thread for an object derived from the Thread class, the start() method should be directly invoked on the Object. This is because the start() method is responsible for creating a new thread and then calling the run() method on that thread. If the run() method is directly invoked, it will run on the current thread instead of creating a new thread. Therefore, the correct way to invoke the run() method on a thread is by calling the start() method on the object.

The order in which threads are resumed after calling the notifyAll() method is not guaranteed. It depends on the underlying thread scheduling algorithm of the operating system. Therefore, you can never be sure which thread will get to run first.

When this code is compiled and executed, a file named "fun.log" is created. The FileWriter object is used to write the string "Hello!" to the file. After writing the content, the writer is closed, which ensures that any buffered data is flushed and the file is properly closed. Therefore, the file "fun.log" is created with the content "Hello!".

When a thread calls the wait() method of an object, it releases the lock of that object and enters a waiting state. This means that the thread no longer owns the lock of the object. Therefore, the given statement is false.

The code creates a class named Test that extends the Thread class. In the main method, an instance of Test is created and its run method is called directly on line 4. Then, the start method is called on the same instance on line 5.

When the code is compiled and run, it will print "run-test" twice because the run method is called directly on line 4, and then the start method will execute the run method again in a separate thread. Therefore, the correct answer is "a).run-test run-test".

The correct answer is a. After object B is notified, or after two seconds.

In this scenario, the wait(2000) method is called, which causes the thread A to wait for a maximum of 2000 milliseconds (2 seconds) or until it is notified by another thread. Once object B is notified, the thread A becomes a candidate to get another turn at the CPU. However, if the 2-second time limit is reached before the notification occurs, the thread A will also become a candidate to get another turn at the CPU.

The code provided defines a class A that extends the Thread class and overrides its run() method. In the main method of the Test class, an object of Test class is created and its check() method is called with an anonymous inner class that extends class A as an argument. The check() method then calls the start() method on the passed object, which starts the execution of the run() method in class A. The run() method prints the values of i (0 and 1) using the System.out.println() method. Therefore, the correct answer is c.0 1.

The correct answer is c because it defines a class called MyRunnable that implements the Runnable interface and provides an implementation for the run() method, which is required by the interface. This allows the MyRunnable object to be used as a target for creating a new Thread.

Explanations : Change value in local methods wouldn’t change in global in case of String ( because String object is immutable).

Thread priorities are set using a positive integer, usually between 1 and 10. t1.setPriority(-3); throws java.lang.IllegalArgumentException.

The correct answer is a.A A A A B B B B. This is because the code creates two threads, t and t1, both using the same instance of class A as the Runnable object. When t starts, it enters the run() method of class A and executes the for loop, printing "A" four times with a 100ms delay between each print. After t finishes executing, t1 starts and also enters the run() method of class A, printing "B" four times with the same delay. Therefore, the output will be "A A A A B B B B".

The correct answer is c.FileInputStream. This class is used to read streams of raw bytes from a file. It is commonly used when dealing with binary files or when you need to read the contents of a file as raw bytes.

The program will print "1 2" and then terminate successfully. The reason is that the code is synchronized on the "args" object, which means that only one thread can execute the synchronized block at a time. The "wait()" method is called on the "args" object, which causes the current thread to wait until another thread notifies it. However, since there are no other threads in this program to notify the waiting thread, it will simply continue executing after the wait() method and print "3". Therefore, the output will be "1 2 3".

When a new thread is created, it inherits the priority of its parent thread. This means that the new thread will have the same priority as the thread that created it. The priority of a thread determines the order in which threads are executed by the thread scheduler. Higher priority threads are given preference over lower priority threads, but the exact behavior depends on the underlying operating system.

The code is trying to read integers from the given input string using a Scanner object. However, when it encounters the character 'a' in the input string, it throws an InputMismatchException because it is unable to parse it as an integer. Therefore, the code will print "1 2" before throwing the exception.

The code creates a file named "apa" and writes the string "apa" into it. The code is executed in a loop that runs twice, so the file "apa" is created and overwritten with the string "apa" twice. Therefore, the final content of the file will be "apa".

Calling the destroy() method of a thread object does not release all the locks held by the thread. The destroy() method is deprecated and should not be used as it is unsafe and can lead to unpredictable behavior. To release locks held by a thread, the proper approach is to ensure that the locks are released within the code executed by the thread itself, either by using try-finally blocks or by using the synchronized keyword appropriately.

The code creates a new PrintWriter object with the file name "yo.txt" as its constructor argument. The code then uses the print() method of the PrintWriter object to write the string "yo" to the file. The flush() method is called to ensure that any buffered data is written to the file, and then the close() method is called to close the file. Therefore, when the code is compiled and executed, a file named "yo.txt" is created with the content "yo".

The code will compile successfully, but it will throw a runtime exception because the start() method of the Thread class can only be called once. In this code, the start() method is called twice on the same Thread object 't', which is not allowed.

The methods of the Thread class are used to control and manage threads in Java. The correct answers are:

a. public void run(): This method is used to define the code that will be executed when the thread is started.

b. public void start(): This method is used to start the execution of the thread.

e. public final void setPriority(int priNbr): This method is used to set the priority of the thread.

f. public final int getPriority(): This method is used to get the priority of the thread.

Explanations : This is a bit of a sneaky one as I have swapped around the names of the methods you need to define and call when running a thread.
If the for loop were defined in a method called public void run() and the call in the main method had been to b.start() The list of values from 0 to 9
would have been output.

Explanations : If you call the run method directly it just acts as any other method and does not return to the calling code until it has finished. executing

In order to ensure that instances of this class can be safely used by multiple threads, both the log() and getContents() methods should be synchronized. Synchronizing the log() method will prevent multiple threads from accessing and modifying the contents StringBuilder object simultaneously, ensuring thread safety while writing messages. Synchronizing the getContents() method will prevent multiple threads from accessing the contents StringBuilder object while retrieving its contents, ensuring thread safety while reading the messages. By synchronizing both methods, we can ensure that the class can be safely used by multiple threads.

The code will throw an exception at runtime because the wait() method can only be called on an object that is currently being synchronized, and in this case, the object being synchronized is the main thread. Since the main thread is not currently in a synchronized block, calling wait() on it will result in an IllegalMonitorStateException.

The code will fail to compile because the method `getLine()` does not exist in the BufferedReader class.

The code creates an instance of the CardPlayer class and serializes it to a file named "play.txt". Then, it reads the serialized object from the file and casts it back to a CardPlayer object.

The output of the program is "pcp".


- When the CardPlayer object is created, it first calls the constructor of the superclass Player, which prints "p".
- Then, it calls its own constructor, which prints "c".
- After serializing and deserializing the object, the main method prints "p" again.
- Finally, it prints "c" when the constructor of the CardPlayer object is called again.

Therefore, the output is "pcp".

When the yield() method is invoked on a running thread, it will be placed in a sleeping state. This means that the thread voluntarily gives up its current execution and allows other threads to run. The sleeping state is a state in which the thread is not actively executing, but it is still eligible to be scheduled and resume its execution later. This allows for fair scheduling of threads and can help prevent starvation.

The given code is a Java program that uses regular expressions to count the number of occurrences of a specific pattern in a given input string. The regular expression pattern is provided as the first command line argument, and the input string is provided as the second command line argument.

In this case, the regular expression pattern "\d+" matches one or more digits. The input string "ab2c4d67" contains the digits 2, 4, and 67, so the pattern matches three times. Therefore, the result of the program is 3, which corresponds to option b.

The code initializes the variable "name" as null and then creates a new File object with the directory path "/folder" and the null value of "name". Since the "name" variable is null, the File object will not point to any specific file. Therefore, the exists() method will return false because there is no file at the specified directory path.

The correct answers are b. public Thread(String name), c. public Thread(Runnable trgt), and d. public Thread(ThreadGroup grp, Runnable trgt, String name). These options represent valid constructors for a Thread object. The first constructor allows you to specify a name for the thread, the second constructor takes a Runnable object as a parameter, and the third constructor allows you to specify a thread group, a runnable object, and a name for the thread.

The code creates a class A that extends Thread and overrides the run() method. In the run() method, it prints "run" and then enters a synchronized block using "this" as the lock. Inside the synchronized block, it runs a loop from 0 to 49 and adds the value of "i" to the "count" variable. After the loop, it calls notify() to notify any waiting threads.

In the main method of the Test class, it creates an instance of class A and starts the thread. Then it enters a synchronized block using the instance "a" as the lock. Inside the synchronized block, it prints "waiting" and then calls a.wait() to wait for the thread "a" to complete. Once the thread "a" completes and calls notify(), the main thread continues and prints the value of "a.count", which is 1225.

Therefore, the output of the code is "waiting run 1225".

The notifyAll() method must be called from a synchronized context because it is used to wake up all threads that are waiting on the same object's monitor. In order to access an object's monitor and call notifyAll(), the calling thread must first acquire the lock on that object by entering a synchronized block or method. This ensures that only one thread at a time can call notifyAll() and prevent any race conditions or conflicts between threads.

Instances of the Car class and its subclass Ford can be serialized. This is because the Car class implements the Serializable interface, which allows its instances to be converted into a byte stream and saved to a file or transmitted over a network. The Ford class is a subclass of Car, so it inherits the Serializable interface and can also be serialized. The Dodge class, although a subclass of Car, cannot be serialized because it contains a non-serializable member variable (Wheels). The Vehicle class and the Wheels class do not implement the Serializable interface and therefore cannot be serialized.

The correct answer includes two methods declared in the java.lang.Thread class. The first method is "public static void sleep(long millis, int nanos)" which allows the thread to sleep for the specified number of milliseconds and nanoseconds. The second method is "public static native void sleep(long millis)" which also allows the thread to sleep for the specified number of milliseconds.

The correct answers are the methods that use the "synchronized" keyword to ensure exclusive access to the variables "a" and "b". By synchronizing the methods, concurrent access problems can be prevented because only one thread can access the variables at a time. The first correct answer is "public synchronized int read(){return a+b;}" because it synchronizes the read method, and the second correct answer is "public synchronized void set(int a, int b){this.a=a;this.b=b;}" because it synchronizes the set method. The third option, "public int read(){synchronized(this){return a+b;}} public void set(int a, int b){synchronized(this){this.a=a;f.this.b=b;}}", is incorrect because it synchronizes the methods using the "this" reference, which does not provide exclusive access to the variables.

The classes InputStream and Reader are both abstract classes defined in the java.io package and used for file-handling. These classes provide a framework for reading data from a file, but they cannot be instantiated directly. Instead, they are meant to be extended by concrete subclasses that provide specific implementations for reading different types of data. This abstraction allows for greater flexibility and modularity in file-handling operations.

The wait(), notify(), and notifyAll() methods must be executed in synchronized code because these methods are used for inter-thread communication and synchronization. By executing these methods in synchronized code, we ensure that only one thread at a time can access and modify the shared data, preventing any potential race conditions or inconsistencies. The notify() and notifyAll() methods can be used to signal and move waiting threads to ready-to-run state, allowing them to continue their execution once the necessary conditions are met.

The output String s will include "e2", ".e1", "=s", and "fly". The condition "if(x.equals(343))" evaluates to true, so ".e2" is added to the String s. The condition "if(s1 == 7)" also evaluates to true, so "=s" is added to the String s. Finally, the condition "if(s1