线性安全和非线性安全的区别

线性安全：就是当多线程访问时，采用了加锁的机制；即当一个线程访问该类的某个数据时，会对这个数据进行保护，其他线程不能访问，直到这个线程读取完之后，其他线程才可以使用，防止出现数据不一致或者数据被污染的情况。

非线性安全（线性不安全）：就是不提供数据访问时的数据保护，多个线程可以同时操作某个数据，从而出现数不一致或者数据污染的情况。

简单的去理解就是，线性安全是多线程操作同一个对象不会出现问题，非线性安全（线性不安全）是多线程操作同一个对象 可能 会出现问题。

存在线程安全问题必须满足三个条件：

1.多线程

2.有共享变量

3.对共享变量有修改操作

线程安全工作原理：

jvm中有一个Main Memory，每一个线程也有自己的Working Memory,一个线程对于一个变量variable进行操作的时候，都需要在自己的Working Memory里创建一个变量的副本copy，操作完之后再写入Main Memory。也就是说，当多线程操作同一个变量variable，可能会出现不可预知的后果。

------------------------------

1.主内存（Main Memory）

主内存可以理解为计算机中的内存，但是又不完全相同。主内存被所有线程共享（比如静态变量，或者堆内存）来说，内存当中存储了他的“本尊”。
2.工作内存（Working Memory）

工作内存可以简单理解为计算机中的CPU高速缓存，但又不完全相同。每一个线程拥有自己的工作内存，对于一个共享变量来说，工作内存当中存储了他的“副本”。

线程对共享变量的所有操作都必须在工作内存进行，不能直接读写主内存中的变量。不同线程之间也无法访问彼此的工作内存，变量值的传递只能通过主内存来进行。

例子：开启10个线程，每个线程当中让静态变量count自增100次之后。执行之后会发现，最终count的结果值未必是1000，有可能是小于1000.（这里count是线程间的共享变量）

public class Test {
    public static int count = 0;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //开启10个线程
        for(int i = 0; i < 10; i++){
            new Thread(
                    new Runnable(){
                        public void run(){
                            try{
                                Thread.sleep(1);
                            }
                            catch(InterruptedException e){
                                e.printStackTrace();
                            }
                            //每个线程中让count自增100次
                            for(int j = 0; j < 100; j++){
                                count++;
                            }
                        }
                    }).start();
        }
        try{
            Thread.sleep(2000);
        }
        catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("count= "+count);
    }
}
//运行结果：count= 952
假设count=2时，当线程1在将count++的结果（count=3）写入内存之前，线程2已经从内存中读取了count的值，并在这个值（count=2）上进行++操作，先于线程1将count=3写入了内存，这是线程1再将count=3写入内存，就存在错误了。
使用synchronized同步方法改进：

public class VolatileTest {
    public static int count = 0;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 开启10个线程
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 每个线程中让count自增100次
                    for (int j = 0; j < 100; j++) {
                        count(); //count++;
                    }
                }
            }).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("count= " + count);
    }

    public static synchronized void count() {
        count++;
    }
}
运行结果：
count=1000

java中实现线程安全的方法：
1.最简单的方法，使用synchronization关键字
用synchronized的关键是建立一个监控，这个monitor可以是要修改的变量，也可以是其他自己认为合适的对象（方法），然后通过给这个monitor加锁来实现线程安全，每个线程在获得这个锁之后，要执行加载（load）到working memory在到使用（use）&&指派（assign）到
存储（store）再到main memory的过程。才会释放他得到的锁。这样就实现了所谓的线程安全。

 2.使用java.util.concurrent.atomic包中的原子类，例如AtomicInteger

3.使用java.util.concurrent.locks包中的锁

4.使用线程安全的集合ConcurrentHashMap

5.使用volatile关键字，保证变量的可见性（直接从内存读，而不是从线程catch读）

---------------------------------

内容来源：https://www.cnblogs.com/zeroingToOne/p/9524543.html