Develop Reference

java - Thread.sleep

In the code and output below, t2 doesn't start until t1 finishes. Shouldn't they work parallel? Is Thread.sleep() affect whole process?
public class Main {
public static void main(String[] args) {
T t1 = new T(), t2 = new T();
t1.run();
t2.run();
}
}
class Test {
private int x;
void foo() {
synchronized (this){
System.out.println("Entered");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Exit");
}
}
}
class T extends Thread {
static Test t = new Test();
public void run() {
System.out.println("Thread started");
t.foo();
}
}
Output:
Thread started
Entered
Exit
Thread started
Entered
Exit

If you want to run these as separate threads, you need to call the Thread.start() method.
Instead, you're calling the run() method directly. The two calls will execute in the same thread as the caller.
As an aside, usually you can just subclass Runnable rather than Thread. Then you can choose to pass your Runnable to the Thread(Runnable) constructor -- or to an ExecutorService.

Synchronizing on a static object

I am really confused on how synchronization actually work. I have this following code:
public class FunTest {
static FunTest test;
public void method() {
synchronized (test) {
if (Thread.currentThread().getName() == "Random1") {
try {
wait();
} catch (InterruptedException ex) {
ex.printStackTrace();
}
} else {
notify();
}
}
}
public static void main(String[] args) {
test = new FunTest();
final FunTest t0 = new FunTest();
Thread t1 = new Thread(new Runnable() {
public void run() {
t0.method();
}
});
Thread t3 = new Thread(new Runnable() {
public void run() {
t0.method();
}
});
t1.setName("Random1");
t3.setName("Random2");
t1.start();
t3.start();
}
}
The code throws IllegalMonitorStateException when run. I don't understand why this is happening. Is it not possible to acquire lock this way?
If I replace test with this in synchronization block it works fine though. Why is this so?

You're opening a monitor block on test, but your applying wait() and notify() to this.

According to javadoc of wait()
"The current thread must own this object's monitor"
In your case it is not.
changing t0.method(); to test.method() will work. Not sure about your usecase though.

interrupt one thread inside another thread's run method in Java

I was reading this post and the suggestions given to interrupt one thread from another is
" " " Here are a couple of approaches that should work, if implemented correctly.
You could have both threads regularly check some common flag variable (e.g. call it stopNow), and arrange that both threads set it when they finish. (The flag variable needs to be volatile ... or properly synchronized.)
You could have both threads regularly call the Thread.isInterrupted() method to see if it has been interrupted. Then each thread needs to call Thread.interrupt() on the other one when it finishes." " "
I do not understand how the second approach is possible that is using Thread.isInterrupted().
That is, how can Thread-1 call Thread.interrupt() on Thread-2.
Consider this example, in the main method I start two threads t1 and t2. I want t1 to stop t2 after reaching certain condition. how can I achieve this?
class Thread1 extends Thread {
public void run(){
while (!isDone){
// do something
}
} //now interrupt Thread-2
}
class Thread2 extends Thread {
public void run(){
try {
while(!Thread.isInterupted()){
//do something;
}
catch (InterruptedExecption e){
//do something
}
}
}
public class test {
public static void main(String[] args){
try {
Thread1 t1 = new Thread1();
Thread2 t2 = new Thread2();
t1.start();
t2.start();
} catch (IOException e) {
e.printStackTrace();
}
}
}

The context of this is that you are trying to implement your scheme using thread interrupts.
In order for that to happen, the t1 object needs the reference to the t2 thread object, and then it simply calls t2.interrupt().
There are a variety of ways that t1 could get the reference to t2.
It could be passed as a constructor parameter. (You would need to instantiate Thread2 before Thread1 ...)
It could be set by calling a setter on Thread1.
It could be retrieved from a static variable or array, or a singleton "registry" object of some kind.
It could be found by enumerating all of the threads in the ThreadGroup looking for one that matches t2's name.

public class test {
private static boolean someCondition = true;
public static void main(String[]args){
Thread t2 = new Thread(new someOtherClass("Hello World"));
Thread t1 = new Thread(new someClass(t2));
t2.start();
t1.start();
try {
t1.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
static class someClass implements Runnable{
Thread stop;
public someClass(Thread toStop){
stop = toStop;
}
public void run(){
while(true){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(someCondition && !stop.isInterrupted()){
stop.interrupt();
}
}
}
}
static class someOtherClass implements Runnable{
String messageToPrint;
public someOtherClass(String s){
messageToPrint = s;
}
public void run(){
while(true){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(messageToPrint);
}
}
}
}

You could consider the use of Future interface. It provides a cancel() method.
http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Future.html

Playing with interruption makes your life unnecessarily hard. Besides the fact that your code must know the threads, interruption does not provide any context information about the reason of the interruption.
If you have a condition that is shared by your code possibly executed by different threads, just encapsulate that condition into an object and share that object:
public class Test {
public static void main(String[] args) {
Condition c=new Condition();
new Thread(new Setter(c)).start();
new Thread(new Getter(c, "getter 1")).start();
// you can simply extend it to more than one getter:
new Thread(new Getter(c, "getter 2")).start();
}
}
class Getter implements Runnable {
final Condition condition;
final String name;
Getter(Condition c, String n) { condition=c; name=n; }
public void run() {
while(!condition.isSatisfied()) {
System.out.println(name+" doing something else");
try { Thread.sleep(300); } catch(InterruptedException ex){}
}
System.out.println(name+" exiting");
}
}
class Setter implements Runnable {
final Condition condition;
Setter(Condition c) { condition=c; }
public void run() {
System.out.println("setter: doing my work");
try { Thread.sleep(3000); }
catch(InterruptedException ex){}
System.out.println("setting condition to satisfied");
condition.setSatisfied();
}
}
class Condition {
private volatile boolean satisfied;
public void setSatisfied() {
satisfied=true;
}
public boolean isSatisfied() {
return satisfied;
}
}
The big advantage of this encapsulation is that it is easy to extend. Suppose you want to allow a thread to wait for the condition instead of polling it. Taking the code above it’s easy:
class WaitableCondition extends Condition {
public synchronized boolean await() {
try {
while(!super.isSatisfied()) wait();
return true;
} catch(InterruptedException ex){ return false; }
}
public synchronized void setSatisfied() {
if(!isSatisfied()) {
super.setSatisfied();
notifyAll();
}
}
}
class Waiter implements Runnable {
final WaitableCondition condition;
final String name;
Waiter(WaitableCondition c, String n) { condition=c; name=n; }
public void run() {
System.out.println(name+": waiting for condition");
boolean b=condition.await();
System.out.println(name+": "+(b? "condition satisfied": "interrupted"));
}
}
Without changing the other classes you can now extend your test case:
public class Test {
public static void main(String[] args) {
WaitableCondition c=new WaitableCondition();
new Thread(new Setter(c)).start();
new Thread(new Getter(c, "getter 1")).start();
// you can simply extend it to more than one getter:
new Thread(new Getter(c, "getter 2")).start();
// and you can have waiters
new Thread(new Waiter(c, "waiter 1")).start();
new Thread(new Waiter(c, "waiter 2")).start();
}
}

Second Thread does not give an output (java)

class firstThread extends Helper1
{
Thread thread_1 = new Thread(new Runnable()
{
#Override
public void run() {
try {
for (int i = 1; i <= 20; i++) {
System.out.println("Hello World");
Thread.sleep(500);
if (i == 10) {
Notify();
Wait();
}
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
class secondThread extends firstThread
{
Thread thread_2 = new Thread(new Runnable()
{
#Override
public void run() {
// TODO Auto-generated method stub
try {
Wait();
for(int i = 1; i<=20; i++)
{
System.out.println("Welcome");
Thread.sleep(100);
}
Notify();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
class Helper1
{
public synchronized void Wait() throws InterruptedException
{
wait();
}
public synchronized void Notify() throws InterruptedException
{
notify();
}
}
public class InheritanceClass {
public static void main(String[] args)
{
Thread f = new Thread(new firstThread().thread_1);
Thread s = new Thread(new secondThread().thread_2);
f.start();
s.start();
}
}
Only the first Thread has an output. Please try my code. I don't know why it happens.
The second thread does not give output, I suppose it's because of Wait() in the secondThread, I don't know what to do.

The problem is with the following code:
class Helper1
{
public synchronized void Wait() throws InterruptedException
{
wait();
}
public synchronized void Notify() throws InterruptedException
{
notify();
}
}
Above, the wait() and notify() calls are equivalent to this.wait() and this.notify(). However, thread1 and thread2 are separate objects so they are not ever going to communicate via this method.
In order for communication to occur, you need a shared lock object. For example:
Object lock = new Object();
firstThread = new firstThread(lock);
secondThread = new secondThread(lock);
and synchronizations like:
void wait(Object lock) {
synchronized(lock) {
lock.wait();
}
}
void notify(Object lock) {
synchronized(lock) {
lock.notify();
}
}
Disclaimer: I would never do this personally, however it does answer the OP's question.

This code is really confusing, which is making it hard to see the underlying problem.
You should never start a class with a lower-case letter since it makes it look like a method/field name (e.g. firstThread).
I'm pretty sure Wait and Notify have no reason to be synchronized.
Why does secondThread inherit from firstThread??? Actually, why do you have those two classes at all? You should just make an anonymous inner class from Helper1 or something.
Anyway, the problem is that when you call Notify() in thread1 it notifies itself, not thread2.

Thread syncronization

I am developing an application in which I have 3 threads.
Let us call them a,b,c.
Now I have to develop something like this.
Initially b waits for a to complete its task, and c waits for b.
As soon as 'a' finishes its task it notifies 'b'. 'b' should wake up. Now 'a' goes to wait state. 'a' will wait until it gets an acknowledgement from 'c'.
Now b finishes its task and notifies 'c'. Now 'c' wakes up and 'b' goes to wait state.
Now c finishes the task and acknowledges to 'a'. Now 'c' goes to wait.
This is circular process and continues from a -> b , b -> c, c->a
In between this cycle all threads access queues for data transfer i.e. 'a' puts data in queue q1, 'b' fetches it and puts in another queue q2, 'c' fetches from q2 and process it and give back to 'a'
I am stuck while implementing this functionality.
Any idea about how this can be done?
Thanks...

If you are allowed to use queues (it seems homework) then you can do something more elegant. Probably the resultant internal lockings are similar to solutions with semaphores, but more elegant.
Create 3 queues, one for each pair of processes. They don't send real data, just the signal to start.
Queue<Integer> queueA2B = new BlockingQueue<Integer>();
Queue<Integer> queueB2C = new BlockingQueue<Integer>();
Queue<Integer> queueC2A = new BlockingQueue<Integer>();
// initialize only the queue that *feeds* A:
queueC2A.put(1);
Each process must take an item from its queue, do its process and send a signal to the next. By example A:
while (...) {
queueC2A.take(); // this will block until there's something in the queue
// do my stuff
queueA2B.put(1); // send "signal" to the next process
}

Nice question, I have written a small class that will demonstrate how Semaphores can be used to run threads in a sequence. Hope this helps:
public class LockingDemo{
private Semaphore a = new Semaphore(0);
private Semaphore b = new Semaphore(0);
private Semaphore c = new Semaphore(1);
class A implements Runnable{
#Override
public void run() {
try {
c.acquire(1);
System.out.println("Doing A");
a.release(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class B implements Runnable{
#Override
public void run() {
try{
a.acquire(1);
System.out.println("Doing B");
b.release(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class C implements Runnable{
#Override
public void run() {
try{
b.acquire(1);
System.out.println("Doing C");
c.release(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void a() throws InterruptedException{
new Thread(new A()).start();
}
public void b() throws InterruptedException{
new Thread(new B()).start();
}
public void c() throws InterruptedException{
new Thread(new C()).start();
}
public static void main(String[] args) throws InterruptedException {
LockingDemo ld = new LockingDemo();
System.out.println("FIRST RUN CALLING B -> A -> C");
ld.b();
ld.a();
ld.c();
Thread.currentThread().sleep(2000);
System.out.println("SECOND RUN CALLING C -> B -> A");
ld.c();
ld.b();
ld.a();
}
}
Here is the OUTPUT
FIRST RUN CALLING B -> A -> C
Doing A
Doing B
Doing C
SECOND RUN CALLING C -> B -> A
Doing A
Doing B
Doing C

I would do it with semaphores. The threads are requiring their own semaphore and when finished, release the next semaphore. You can of course also do this with monitors (Object#wait() and Object#notify()). To ensure them running in a circular fashion, you simply let them run in endless loops and waiting for the semaphores to be filled:
import java.util.concurrent.Semaphore;
public class Main {
private Semaphore a = new Semaphore(1), b = new Semaphore(0), c = new Semaphore(0);
public class A implements Runnable {
#Override
public void run() {
while (true) {
try {
a.acquire(1);
Thread.sleep((long) (Math.random() * 1000));
System.out.println("performing task A");
b.release(1);
} catch (InterruptedException e) {}
}
}
}
public class B implements Runnable {
#Override
public void run() {
while (true) {
try {
b.acquire(1);
Thread.sleep((long) (Math.random() * 1000));
System.out.println("performing task B");
c.release(1);
} catch (InterruptedException e) {}
}
}
}
public class C implements Runnable {
#Override
public void run() {
while (true) {
try {
c.acquire(1);
Thread.sleep((long) (Math.random() * 1000));
System.out.println("performing task C");
a.release(1);
} catch (InterruptedException e) {}
}
}
}
public void startThreads() {
new Thread(new A()).start();
new Thread(new B()).start();
new Thread(new C()).start();
}
public static void main(String[] args) throws InterruptedException {
Main ld = new Main();
ld.startThreads();
}
}
The cool thing with this solution as opposed to monitors is that you can simply fill up a semaphore from the outside to start a second "thread-worm" to run in circles.