// 定義消息服務接口  
interface MessageService {  
    void sendMessage(String message);  
}  
// 實現(xiàn)消息服務的類  
class EmailService implements MessageService {  
    @Override  
    public void sendMessage(String message) {  
        System.out.println("Sending email: " + message);  
    }  
}  
// 消息發(fā)布者類  
class MessagePublisher {  
    // 使用volatile修飾的變量，確保所有線程都能看到最新的值  
    private volatile boolean isPublishingActive = false;  
    // 消息服務接口的實現(xiàn)  
    private final MessageService messageService;  
    public MessagePublisher(MessageService messageService) {  
        this.messageService = messageService;  
    }  
    // 激活消息發(fā)布  
    public void activatePublishing() {  
        isPublishingActive = true;  
        publishMessage("Hello, World!");  
    }  
    // 停止消息發(fā)布  
    public void deactivatePublishing() {  
        isPublishingActive = false;  
    }  
    // 根據(jù)isPublishingActive的狀態(tài)決定是否發(fā)送消息  
    private void publishMessage(String message) {  
        if (isPublishingActive) {  
            messageService.sendMessage(message);  
        } else {  
            System.out.println("Publishing is not active, message not sent: " + message);  
        }  
    }  
}  
// 主類，用于演示  
public class Main {  
    public static void main(String[] args) {  
        MessageService emailService = new EmailService();  
        MessagePublisher publisher = new MessagePublisher(emailService);  
        // 激活發(fā)布  
        publisher.activatePublishing();  
        // 嘗試發(fā)送消息  
        publisher.publishMessage("Test Message");  
        // 停止發(fā)布  
        publisher.deactivatePublishing();  
        // 再次嘗試發(fā)送消息，此時不會發(fā)送  
        publisher.publishMessage("Another Test Message");  
    }  
}

public class MyClass {  
    // 聲明一個volatile變量  
    private volatile int count = 0;  
    // 訪問和修改count的方法  
    public void increment() {  
        count++; // 注意：這里可能不是線程安全的，因為count++不是原子操作  
    }  
    public int getCount() {  
        return count;  
    }  
}

public class VolatileExample {  
    private volatile boolean running = true;  
    public void stopRunning() {  
        running = false;  
    }  
    public void doWork() {  
        while (running) {  
            // 執(zhí)行一些工作  
            System.out.println("Working...");  
            try {  
                Thread.sleep(1000); // 模擬耗時操作  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt();  
            }  
        }  
        System.out.println("Stopped working.");  
    }  
    public static void main(String[] args) throws InterruptedException {  
        VolatileExample example = new VolatileExample();  
        Thread worker = new Thread(example::doWork);  
        worker.start();  
        // 讓工作線程運行一段時間  
        Thread.sleep(5000);  
        // 停止工作線程  
        example.stopRunning();  
        // 等待工作線程結(jié)束  
        worker.join();  
    }  
}