你作为一个Java领域的专家，请完成以下任务：设计模式，设计线程安全和单例的例子

设计模式：代理模式

代理模式是一种结构型设计模式，它允许你提供一个代替另一个对象的替代品，以控制对这个对象的访问。代理对象可以拦截并处理客户端的请求，而不必让客户端访问实际对象。它可以用于远程调用、虚拟代理、保护代理等场景。

例子：

假设我们有一个访问网络资源的接口：

public interface NetworkResource {
    void request(String url);
}

我们可以创建一个代理类来实现这个接口：

public class NetworkResourceProxy implements NetworkResource {
    private NetworkResource networkResource;

    public NetworkResourceProxy(NetworkResource networkResource) {
        this.networkResource = networkResource;
    }

    @Override
    public void request(String url) {
        if (isAccessAllowed(url)) {
            networkResource.request(url);
        } else {
            throw new RuntimeException("Access to resource is not allowed");
        }
    }

    private boolean isAccessAllowed(String url) {
        // Check if access to the resource is allowed
        return true;
    }
}

这个代理类可以拦截客户端的请求，检查是否允许访问该资源，如果允许，则将请求转发给实际的网络资源对象。

设计线程安全的例子：使用锁实现线程安全的计数器

public class Counter {
    private int count = 0;
    private Object lock = new Object();

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

    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

在这个例子中，我们定义了一个计数器类，它有两个方法：increment() 和 getCount()。我们使用一个锁来保证这两个方法的线程安全性。

在 increment() 方法中，我们使用 synchronized 关键字来获得锁，并且在修改计数器的值后释放锁。这样可以确保在一个线程修改计数器时，其他线程不能同时修改它。

在 getCount() 方法中，我们也使用 synchronized 关键字来获得锁，并且在返回计数器的值后释放锁。这样可以确保在一个线程读取计数器的值时，其他线程不能同时修改它。

设计单例的例子：懒汉式单例模式

懒汉式单例模式是一种创建单例对象的方式，在第一次使用单例对象时才创建它。这种方式可以避免在程序启动时就创建单例对象，从而减少内存浪费。

例子：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

在这个例子中，我们定义了一个 Singleton 类，它有一个私有的构造方法和一个静态的 getInstance() 方法。在 getInstance() 方法中，我们使用双重检查锁定来实现单例模式，即在第一次使用单例对象时才创建它，并且使用 synchronized 关键字来保证线程安全性。