要实现并发修改EHCache的多线程Java解决方案，可以通过使用EHCache的ReadWriteLock来实现线程安全的缓存访问。下面是一个示例代码：

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

public class ConcurrentEHCacheExample {
    private Cache cache;

    public ConcurrentEHCacheExample() {
        // 创建缓存管理器
        CacheManager cacheManager = CacheManager.getInstance();
        // 创建缓存实例
        cache = cacheManager.getCache("myCache");
    }

    public void addToCache(String key, Object value) {
        // 获取写锁
        cache.acquireWriteLockOnKey(key);
        try {
            // 将元素添加到缓存
            cache.put(new Element(key, value));
        } finally {
            // 释放写锁
            cache.releaseWriteLockOnKey(key);
        }
    }

    public Object getFromCache(String key) {
        // 获取读锁
        cache.acquireReadLockOnKey(key);
        try {
            // 从缓存中获取元素
            Element element = cache.get(key);
            if (element != null) {
                return element.getObjectValue();
            }
        } finally {
            // 释放读锁
            cache.releaseReadLockOnKey(key);
        }
        return null;
    }

    public static void main(String[] args) {
        ConcurrentEHCacheExample example = new ConcurrentEHCacheExample();
        
        // 创建多个线程同时操作缓存
        Thread thread1 = new Thread(() -> example.addToCache("key1", "value1"));
        Thread thread2 = new Thread(() -> example.addToCache("key2", "value2"));
        Thread thread3 = new Thread(() -> example.addToCache("key3", "value3"));

        Thread thread4 = new Thread(() -> System.out.println(example.getFromCache("key1")));
        Thread thread5 = new Thread(() -> System.out.println(example.getFromCache("key2")));
        Thread thread6 = new Thread(() -> System.out.println(example.getFromCache("key3")));
        
        // 启动线程
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
        thread6.start();

        // 等待线程执行完毕
        try {
            thread1.join();
            thread2.join();
            thread3.join();
            thread4.join();
            thread5.join();
            thread6.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们使用EHCache的acquireWriteLockOnKey和releaseWriteLockOnKey方法获取和释放写锁，以及acquireReadLockOnKey和releaseReadLockOnKey方法获取和释放读锁。这样可以确保在多线程环境下对缓存的并发访问是线程安全的。

在addToCache方法中，我们首先获取写锁，然后将元素添加到缓存中，最后释放写锁。在getFromCache方法中，我们首先获取读锁，然后从缓存中获取元素，最后释放读锁。

在main方法中，我们创建了多个线程同时操作缓存，其中线程1、2、3分别添加了不同的元素到缓存中，线程4、5、6分别从缓存中获取了对应的元素。通过多次运行该示例，可以验证在多线程环境下EHCache的线程安全性。

需要注意的是，EHCache的ReadWriteLock是基于key的，所以在使用ReadWriteLock时，需要根据不同的key获取对应的锁来保证线程安全。