java如何只执行一次

在Java中，只执行一次代码的方式包括使用单例模式、静态代码块、同步代码块、以及使用volatile关键字。 在这些方法中，单例模式是最常用和最推荐的一种方式。在单例模式中，我们确保一个类只有一个实例，并提供一个全局访问点。通过这种方式，可以确保某段代码只执行一次。接下来，我们将详细讨论单例模式的实现方法及其他几种方法。

一、单例模式

单例模式是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点。单例模式可以有效地控制资源的访问，特别是在需要大量资源初始化的情况下。

1.1、饿汉式单例

饿汉式单例在类加载时就进行实例化。它的优点是简单，不需要考虑线程安全问题，但缺点是不能延迟加载，可能会造成资源浪费。

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

在上述代码中，INSTANCE在类加载时就已经初始化，因此在第一次调用getInstance()方法时，不需要进行任何同步操作。

1.2、懒汉式单例

懒汉式单例在第一次使用时才进行实例化。它的优点是可以延迟加载，但缺点是需要考虑线程安全问题。

1.2.1、线程不安全的懒汉式单例

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

上述代码在多线程环境下是不安全的，因为可能会出现多个线程同时进入if (instance == null)语句块，从而创建多个实例。

1.2.2、线程安全的懒汉式单例

方法一：使用`synchronized`关键字

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

使用synchronized关键字可以确保线程安全，但会降低性能，因为每次调用getInstance()方法时都需要进行同步。

方法二：双重检查锁定

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

双重检查锁定可以在保证线程安全的同时，提高性能。volatile关键字确保了实例的可见性和禁止指令重排序。

方法三：静态内部类

public class Singleton {
    private Singleton() {}
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

静态内部类的方式不仅确保了线程安全，而且实现了延迟加载，推荐在实际开发中使用这种方式。

二、静态代码块

静态代码块用于在类加载时执行一段代码，并且只执行一次。静态代码块在类加载时被执行，因此可以用于初始化静态变量或执行一些一次性的操作。

public class StaticBlockExample {
    static {
        // 只执行一次的代码
        System.out.println("静态代码块执行");
    }
    public static void main(String[] args) {
        // 主方法
        System.out.println("主方法执行");
    }
}

在上述代码中，静态代码块在类加载时执行，并且只执行一次，无论创建多少个StaticBlockExample对象，静态代码块只会执行一次。

三、同步代码块

同步代码块可以确保某段代码在多线程环境下只执行一次。通过锁对象，可以确保只有一个线程进入同步代码块。

public class SynchronizedBlockExample {
    private static boolean isExecuted = false;
    private static final Object lock = new Object();
    public static void executeOnce() {
        synchronized (lock) {
            if (!isExecuted) {
                // 只执行一次的代码
                System.out.println("同步代码块执行");
                isExecuted = true;
            }
        }
    }
    public static void main(String[] args) {
        // 多线程环境下测试
        for (int i = 0; i < 10; i++) {
            new Thread(SynchronizedBlockExample::executeOnce).start();
        }
    }
}

在上述代码中，通过synchronized关键字和锁对象lock，可以确保executeOnce方法中的代码在多线程环境下只执行一次。

四、volatile关键字

volatile关键字可以确保变量的可见性和禁止指令重排序。通过volatile关键字，可以确保某个变量在多线程环境下的最新状态，从而实现只执行一次的效果。

public class VolatileExample {
    private static volatile boolean isExecuted = false;
    public static void executeOnce() {
        if (!isExecuted) {
            synchronized (VolatileExample.class) {
                if (!isExecuted) {
                    // 只执行一次的代码
                    System.out.println("volatile关键字执行");
                    isExecuted = true;
                }
            }
        }
    }
    public static void main(String[] args) {
        // 多线程环境下测试
        for (int i = 0; i < 10; i++) {
            new Thread(VolatileExample::executeOnce).start();
        }
    }
}

在上述代码中，通过volatile关键字和双重检查锁定，可以确保executeOnce方法中的代码在多线程环境下只执行一次。

总结

在Java中，实现只执行一次代码的方法有多种选择，包括单例模式、静态代码块、同步代码块和volatile关键字。单例模式是最常用和最推荐的一种方式，特别是在需要全局唯一实例的情况下；静态代码块适用于类加载时需要执行一次的初始化代码；同步代码块和volatile关键字可以确保在多线程环境下某段代码只执行一次。在实际开发中，可以根据具体需求选择合适的方法来确保代码只执行一次。