java线程安全问题的原因和解决方案

一、线程安全问题的原因

1.根本原因

线程在操作系统上是抢占式执行、随即调度，这种方式给线程之间的执行顺序带来了很多的可能性，造成线程不安全。

package BCexercise;

public class E0724 {
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(()->{
           for(int i = 0;i < 10000;i++){
               System.out.println("hello t1");
           }
        });

        Thread t2 = new Thread(()->{
            for(int i = 0;i < 10000;i++){
                System.out.println("hello t2");
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

    }
}

运行结果如下:可以看出t1和t2抢占式打印，顺序并没有确定。 

2.代码结构

我们写的代码的结构很有可能造成线程不安全，在代码中多个线程，同时修改同一个变量，这样使得我们的数据不统一，得不到最后的正确结果。

例如：我们使用两个线程对同一个变量进行自增10000次，我们理想的答案应该是20000。

package BCexercise;

public class E0724 {
    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(()->{
           for(int i = 0;i < 10000;i++){
                   count++;
           }
        });

        Thread t2 = new Thread(()->{
            for(int i = 0;i < 10000;i++){
                    count++;
                }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("count ="+count);
    }
}

运行结果如下：

我们看到的运行结果并非是20000，这是因为这两个线程在对变量进行修改的过程中出现了问题，使得变量最终不为20000。

但我们如果我们在一个线程中修改一个变量；多个线程读取以同一个变量；多个线程修改不同变量；这几种情况是不会造成线程安全的。

3.直接原因

在上述多线程的修改操作中，这些操作本身，本身不是"原子的"，在我们上述例子当中，我们的count++是由多个CPU指令一起执行的，但一个线程执行这些指令的时候，执行到一半就被调度走了。

4.其他原因

内存可见性问题、指令重排序问题

二、解决方案

针对上述的根本原因，我们没有办法去做出该改变，因为这是系统内部已经实现的，我们无法做出干预，对于代码结构问题，我们有失可以做出调整，有时也无法做出调整。

我们目前最主要的解决方式是针对上述的直接原因的，通过特殊手段将CPU指令打包成一个原子操作，这个操作便是加锁，同时如果一个线程，针对同一个对象加上锁之后，其他线程，也尝试对这个对象加锁，就会产生阻塞，一直阻塞到，前一个线程释放锁为止。

package BCexercise;
public class E0724 {

    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();

        Thread t1 = new Thread(()->{
           for(int i = 0;i < 10000;i++){
               synchronized (object){
                   count++;
              }
           }
        });

        Thread t2 = new Thread(()->{
            for(int i = 0;i < 10000;i++){
                synchronized (object){
                    count++;
                }
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("count ="+count);
    }
}

运行实例如下： 

以上可以有效地处理Java中的线程安全问题，确保多个线程能够安全地并发访问共享资源，避免数据竞争和不一致的状态。