在并发程序中，意外值通常是由于多个线程同时访问和修改共享数据而引起的。下面是一些解决意外值问题的方法，包含代码示例：

1. 使用互斥锁（Mutex）： 互斥锁用于控制对共享资源的访问，一次只允许一个线程访问共享资源，其他线程会被阻塞。通过在关键代码段使用互斥锁，可以确保同时只有一个线程访问共享数据。

   import threading
   
   value = 0
   lock = threading.Lock()
   
   def increment():
       global value
       with lock:
           value += 1
   
   def decrement():
       global value
       with lock:
           value -= 1
   

2. 使用原子操作： 原子操作是不可被中断的操作，可以保证在多线程环境下的数据一致性。一些编程语言提供了原子操作的支持，例如Java中的AtomicInteger。通过使用原子操作，可以确保同时只有一个线程修改共享数据。

   import java.util.concurrent.atomic.AtomicInteger;
   
   AtomicInteger value = new AtomicInteger(0);
   
   void increment() {
       value.incrementAndGet();
   }
   
   void decrement() {
       value.decrementAndGet();
   }
   

3. 使用线程安全的数据结构： 一些编程语言提供了线程安全的数据结构，例如Java中的ConcurrentHashMap。这些数据结构内部实现了线程安全的访问和修改操作，可以避免意外值的问题。

   import java.util.concurrent.ConcurrentHashMap;
   
   ConcurrentHashMap map = new ConcurrentHashMap<>();
   
   void increment(String key) {
       map.compute(key, (k, v) -> v == null ? 1 : v + 1);
   }
   
   void decrement(String key) {
       map.compute(key, (k, v) -> v == null ? -1 : v - 1);
   }
   

4. 使用信号量（Semaphore）： 信号量可以用于控制对共享资源的访问，可以限制同时访问共享资源的线程数量。通过使用信号量，可以确保同时只有有限数量的线程访问共享数据。

   import threading
   
   value = 0
   semaphore = threading.Semaphore(1)
   
   def increment():
       global value
       semaphore.acquire()
       value += 1
       semaphore.release()
   
   def decrement():
       global value
       semaphore.acquire()
       value -= 1
       semaphore.release()
   

以上是一些常见的解决意外值问题的方法，根据具体的并发编程语言和环境，可能会有其他更适合的解决方案。在编写并发程序时，需要仔细考虑共享数据的访问和修改方式，避免出现意外值和其他并发问题。