Java提供了许多同步机制，例如synchronized关键字和Lock接口，用于保护同时被多个线程访问的字段。下面是使用synchronized关键字的示例：

public class MyClass {
    private int sharedField;
    
    public synchronized void updateField(int value) {
        // 这里的代码是原子操作，只有一个线程能够执行
        sharedField = value;
    }
    
    public synchronized int getField() {
        // 这里的代码也是原子操作，只有一个线程能够执行
        return sharedField;
    }
}

在上面的代码示例中，updateField()和getField()方法都使用了synchronized关键字，表示这些方法是原子操作，并且只能由一个线程执行。

当然，synchronized并不是唯一的解决方法。您还可以使用Lock接口，如下所示：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyClass {
    private int sharedField;
    private Lock lock = new ReentrantLock();
    
    public void updateField(int value) {
        lock.lock();
        try {
            // 这里的代码是原子操作，只有一个线程能够执行
            sharedField = value;
        } finally {
            lock.unlock();
        }
    }
    
    public int getField() {
        lock.lock();
        try {
            // 这里的代码是原子操作，只有一个线程能够执行
            return sharedField;
        } finally {
            lock.unlock();
        }
    }
}

在上面的代码示例中，我们使用了ReentrantLock类实例化了Lock接口，然后在updateField()和getField()方法中使用lock()方法获取锁，使用unlock()方法释放锁。这样一来，我们就可以保证这些方法是原子操作，并且只能由一个线程执行。