We Keep Coding

method interrupted in java,when use it inside while loop will interrupt the thread or not?

If I use this method like this, will it interrupt the thread or not?
while ( !interrupted() && more work to do){ /* main thread execution loop*/ }
2nd question: what does this statement mean?
interrupt() method, does not automatically mean that the thread should
terminate. It simply grabs the attention of the thread (kind of like
poking a sleeping roommate to wake him up)

Calling interrupted() does not “interrupt” execution of code in the Thread. Your condition will, however, cause the loop to exit if the Thread running it is interrupted by another thread calling interrupt() on it, assuming no other code in the loop calls interrupted() (which clears the current Thread’s interrupted status).
The text you have quoted is explaining that a Thread’s code must act on an interrupt, by checking the Thread’s interrupted status, or by calling a method capable of throwing InterruptedException (or ClosedByInterruptException). If the Thread’s code does none of those things, calling interrupt() on that Thread will have no effect on code execution; it will merely set the Thread’s interrupted status, which is just a boolean property of the Thread. Code must properly respond to interrupts for interrupts to be effective.

wait() is always throwing InterruptedException

The below wait() call is always throwing InterruptedException. It is not that some other thread is interrupting it. There is no delay between the call and the exception being thrown. I have put logs to check the time lapse between the call and the catch of exception.
Also, Thread.sleep(long) yields the same result.
public synchronized void retryConnection()
{
// . .. some code
try
{
wait();
}
catch(InterruptedException e)
{
log(Level.SEVERE, "InterruptedException " , e);
}
// . .. some code
}
I have tried these random things:
call this method in a new thread. Then it works fine. It is a waiting and notification mechanism also works.
put the same code again, that is, wait again after the exception is caught. Then it is properly waiting.
Observation: When the call is coming from a netty(server) thread, it fails but if it is coming from some other java thread, it works. So my question is: Is there any mechanism or thread state where wait() or Thread.sleep() is forbidden and throws an exception if they are invoked?
I have checked the interrupted flag and it is 'false' always.

InterruptedException is a perfectly normal event to occur when using Object.wait(), and thread.sleep() coupled with Object.notify(), and Object.notifyAll().
This is called Inter-thread Communication.
A thread which owns the object's monitor, can call Object.wait() - a call which causes this current thread to lose the ownership of the monitor and to wait / block until another thread owning said object's monitor will call Object.notify() or Object.notifyAll().
This means that active thread owning the lock awakes other thread(s) from waiting (or sleeping, or blocking) state. This originating thread has to also relinquish its grasp on objects lock, before the thread(s) that got notified can proceed.
The thread which is waiting on a lock receives the notification as InterruptedException. It then can proceed as by the time it has received the exception, it has been given the ownership of the lock.
Please see Java Thread lifecycle diagram to for more information.
So in your case:
Receiving InterruptedException is not a failure.
Netty trying to be performant, does not let threads wait too long, hence you keep getting the notifications.
When you run your threads, you don't call notify() or notifyAll() and the exception is never thrown
For both Object.wait() and Thread.sleep() you get the following (from javaDoc):
The interrupted status of the current thread is cleared when this exception is thrown.

why Thread.currentThread.interrupt() combined with return can stop a current running thread

Well, I am trying to understand why the following combination of Thread.currentThread.interrupt() and return is working fine, when I want to terminate a current thread.
Thread.currentThread.interrupt();
return;
I write a small program:
public class Interr implements Runnable {
#Override
public void run() {
for(int i= 0; i<10000;i++){
System.out.println(i);
if(i==500){
Thread.currentThread().interrupt();
return ;
}
}
}
public static void main(String args []){
Thread thread = new Thread(new Interr());
thread.run();
}
}
I know I can also use Thread.currentThread.stop() but it is an unsafe way to terminate a thread. So I tried to use the combination interupt() and return.
It works but I do not undestand why it works.
Any Explanation?
Edit: in the above example, I am the owner of a Thread. Assume, I am not the owner of a thread. Why This combination is working?

You don't need interrupt(). The return is enough to exit run() which will then cause the thread to stop, since it has no more work to do.

No need to call interrupt() from same thread.
interrupt method will be used to interrupt a thread from other thread.
as per java docs.
Interrupts this thread. Unless the current thread is interrupting
itself, which is always permitted, the checkAccess method of this
thread is invoked, which may cause a SecurityException to be thrown.
If this thread is blocked in an invocation of the wait(), wait(long),
or wait(long, int) methods of the Object class, or of the join(),
join(long), join(long, int), sleep(long), or sleep(long, int), methods
of this class, then its interrupt status will be cleared and it will
receive an InterruptedException.
If this thread is blocked in an I/O operation upon an interruptible
channel then the channel will be closed, the thread's interrupt status
will be set, and the thread will receive a ClosedByInterruptException.
If this thread is blocked in a Selector then the thread's interrupt
status will be set and it will return immediately from the selection
operation, possibly with a non-zero value, just as if the selector's
wakeup method were invoked.
If none of the previous conditions hold then this thread's interrupt
status will be set.
Interrupting a thread that is not alive need not have any effect.
So it will send interrupt signal to the thread which is in I/O block.
#Override
public void run() {
while (true) {
}
}
if a thread has implementation like that , it wont interrupt even after calling this method.

Actually in the code you posted the reason the thread stops is because you called return.
As per the documentation, calling Thread.interrupt() does nothing more than set a flag on the thread you're calling it on. The owner of the thread checks the flag and must find a way to stop what it is doing.

Why interrupt the current thread when it is already running?

I am learning locking mechanism in java and found out some code which was given as a example in the LockSupport class in which the thread interrupting itself by calling interrupt() method. I am very confused that when a thread is already running then why it is interrupting itself.
I also want to clear all of you that I know what happen when the current thread is interrupted inside the catch block but I want to know what happen when running Thread interrupt itself.
code from LockSupport
sample code is here
class FIFOMutex {
private final AtomicBoolean locked = new AtomicBoolean(false);
private final Queue<Thread> waiters = new ConcurrentLinkedQueue<Thread>();
public void lock() {
boolean wasInterrupted = false;
Thread current = Thread.currentThread();
waiters.add(current);
// Block while not first in queue or cannot acquire lock
while (waiters.peek() != current || !locked.compareAndSet(false, true)) {
LockSupport.park(this);
if (Thread.interrupted()) // ignore interrupts while waiting
wasInterrupted = true;
}
waiters.remove();
if (wasInterrupted) // reassert interrupt status on exit
current.interrupt(); // Here it is interrupting the currentThread which
}
public void unlock() {
locked.set(false);
LockSupport.unpark(waiters.peek());
}
}

I want to know what happen when running Thread interrupt itself.
The interrupt flag is set to true nothing else. Nothing magically like triggering an exception or signalling the thread.
If you interrupt another thread which is blocked on a interruptable method, this would trigger that method to throw an InterruptedException.
When you call
Thread.interrupted()
this clears the flag and if you want set it again, you need to use interrupt() to set the flag to true so other code can detect that the thread was interrupted.
A simpler solution is to use Thread.currentThread().isInterrupted() which doesn't clear the flag.

This is because Thread.interrupted() not only checks that the interrupt flag is set on the current thread, it also clears it!
Therefore it is needed to re-enable it.
The better solution here is to use Thread.currentThread().isInterrupted(), whih does not clear the interrupt flag.
And yes, it is only this: a flag. You don't "signal" a thread, in essence. When you receive an interrupted exception, it is because the callee will have detected that the interruption flag was set and thrown this exception (or "bubbled it up" from below). It doesn't happen "automagically".
In other words: in Java, thread interruption is a cooperative process.

What happens is that Thread.interrupted() returns and clears the thread interrupted flag; the code just resets the flag at the end; essentially postponing thread interrupts for a while.

why need to catch InterruptedException in the Sleep? [duplicate]

This question already has answers here:
Closed 11 years ago.
Possible Duplicate:
When does Java's Thread.sleep throw InterruptedException?
I saw we have to catch InterruptedException in the Thread.Sleep method, why? I never saw this exception occured in the real time. Any clue?

This happens if thread#1 is sleeping, and another thread interrupts it. This is usually an attempt to stop thread#1. For example, thread#1 is sleeping while doing some long-running task (perhaps in background) and the user hits a cancel button.

The IterruptedExeption is thrown when a thread is waiting, sleeping, or otherwise occupied, and the thread is interrupted, either before or during the activity. Occasionally a method may wish to test whether the current thread has been interrupted, and if so, to immediately throw this exception. The following code can be used to achieve this effect:
if (Thread.interrupted()) // Clears interrupted status!
{
throw new InterruptedException();
}
Every thread has a Boolean property associated with it that represents its interrupted status. The interrupted status is initially false; when a thread is interrupted by some other thread through a call to Thread.interrupt(), one of two things happens. If that thread is executing a low-level interruptible blocking method like Thread.sleep(), Thread.join(), or Object.wait(), it unblocks and throws InterruptedException. Otherwise, interrupt() merely sets the thread's interruption status. Code running in the interrupted thread can later poll the interrupted status to see if it has been requested to stop what it is doing; the interrupted status can be read with Thread.isInterrupted() and can be read and cleared in a single operation with the poorly named Thread.interrupted(). See.
There is no way to simply stop a running thread in java (don't even consider using the deprecated method stop()). Stopping threads is cooperative in java. Calling Thread.interrupt() is a way to tell the thread to stop what it is doing. If the thread is in a blocking call, the blocking call will throw an InterruptedException, otherwise the interrupted flag of the thread will be set.
The problem is that blocking calls like sleep() and wait(), can take very long till the check can be done. Therefore they throw an InterruptedException. (However the isInterrupted is cleared when the InterruptedException is thrown.)