解决方法

使用synchronized加锁方式

package org.example.concurrency.test;
import java.util.concurrent.TimeUnit;
/**
 * @author huskyui
 */
public class Test30 {
    static boolean run = true;
    static Object lock = new Object();
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
           while (run){
               // ....
               synchronized (lock){
                   if (!run){
                       break;
                   }
               }
           }
        });
        t1.start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lock){
            run = false;
        }
    }
}

使用volatile,解决可见性问题

package org.example.concurrency.test;
import java.util.concurrent.TimeUnit;
/**
 * @author huskyui
 */
public class Test30 {
    volatile static boolean run = true;
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
           while (run){
           }
        });
        t1.start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        run = false;
    }
}

volatile

volatile只用于一个写线程，多个读线程。只能解决可见性问题，不能保证原子性问题。不能解决指令交错
synchronized可以保证代码块中原子性以及代码块内的变量可见性。但是缺点是很重。

实际应用

我们可以看到锁住是beanDefinitionMap当时用的却是beanDefinitionNames.