Java：多线程访问主线程变量/方法

Question

I was testing the following code, and I was wondering how come the threads could access the the increment method?

I was thinking this since thread1 and thread2 are objects created from an anonymous class that don't inherit worker class how can they access the increment() method? what is the theory behind it?

public class Worker {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public void run() {
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                for(int i = 0; i < 10000; i++) {
                    increment();
                }
            }
        });
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                for(int i = 0; i < 10000; i++) {
                    increment();
                }
            }
        });
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("Count is: " + count);
    }
}

Answer 1

Since the Runnable s are non-static inner classes , the Worker.this is implicitly inherited into the Runnable instances. So that what is really happening is

public void run(){
   Worker.this.increment();
}

If the class were static this wouldn't be the case.

Answer 2

The Java Language Specification (JLS) states this about Inner Classes and Enclosing Instances

Inner classes include local (§14.3), anonymous (§15.9.5) and non-static member classes (§8.5).

and about Inner Classes and Enclosing Instances

An inner class C is a direct inner class of a class O if O is the immediately lexically enclosing class of C and the declaration of C does not occur in a static context.

and finally about Qualified this

Any lexically enclosing instance (§8.1.3) can be referred to by explicitly qualifying the keyword this .

Let C be the class denoted by ClassName . Let n be an integer such that C is the n'th lexically enclosing class of the class in which the qualified this expression appears.

The value of an expression of the form ClassName.this is the n'th lexically enclosing instance of this .

That's why you can access members of Worker .

The call

new Runnable()

within a Worker instance method, creates an inner class for Worker . So Worker is the 0'th lexically enclosing class of that Runnable . With regards to the JLS quotes above, replace ClassName with Worker and you have access to your method

Worker.this.increment()

It's done implicitly by the compiler

Answer 3

An anonymous inner class has access to the enclosing class instance fields and methods. In short, every instance of the inner class keeps a reference to the enclosing class precisely so that it is able to access its fields. If you want more info about inner classes, static classes, etc... check out the Java Tutorials on that topic (Nested Classes) at: http://docs.oracle.com/javase/tutorial/java/javaOO/nested.html Also, make sure to understand the dangers associated with non-static inner classes, as they can be troublesome and create memory leaks if you hand out references to the inner instance to code outside of the enclosing class.

Answer 4

Because it's a non-static inner class, it captures a reference to the Worker instance it is created within. That means you can invoke methods of the worker inside the anonymous class.

Answer 5

The "theory" is described in inner classes . The practice is, inner class constructors have hidden parameter which refers to outer class instance, and that parameter is saved in a hidden field. This field can be accessed with Worker.this construct from inner class methods.