关于synchronized关键字,该如何解决

关于synchronized关键字

package concurrency2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AtomicityTest implements Runnable
{
	private  int i=0;
	public synchronized int getValue(){
		return i;
	}
	private synchronized void evenIncrement()
	{
		i++;i++;
	}
	@Override
	public void run()
	{
		while(true)
		{
			evenIncrement();
		}
	}
	public static void main(String[] args)
	{
		ExecutorService es=Executors.newCachedThreadPool();
		AtomicityTest at=new AtomicityTest();
		es.execute(at);
		while(true)
		{
			int val=at.getValue();
			if (val%2!=0)
			{
				System.out.println(val);
				System.exit(0);
			}
		}
	}
}

我觉得程序在执行到at.getValue去return i 的时候，另外一个2个i++的循环，有可能只执行了一个i++啊，这样不也是线程不安全么？
synchronized关键字在里面起的作用不只是同步方法是么？求高手赐教
------解决方案--------------------
找了许久，终于找到了～～～
http://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html

The Java programming language provides two basic synchronization idioms: synchronized methods and synchronized statements. The more complex of the two, synchronized statements, are described in the next section. This section is about synchronized methods.

To make a method synchronized, simply add the synchronized keyword to its declaration:

public class SynchronizedCounter {
    private int c = 0;

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

    public synchronized void decrement() {
        c--;
    }

    public synchronized int value() {
        return c;
    }
}

If count is an instance of SynchronizedCounter, then making these methods synchronized has two effects:

    First, it is not possible for two invocations of synchronized methods on the same object to interleave. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object.
    Second, when a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads.