线程安全和线程不安全理解

时间 2019-11-07

原文原文链接

线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其余线程不能进行访问直到该线程读取完，其余线程才可以使用。不会出现数据不一致或者数据污染。线程不安全就是不提供数据访问保护，有可能出现多个线程前后更改数据形成所获得的数据是脏数据html

概念：java

若是你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。若是每次运行结果和单线程运行的结果是同样的，并且其余的变量的值也和预期的是同样的，就是线程安全的。设计模式

或者说:一个类或者程序所提供的接口对于线程来讲是原子操做或者多个线程之间的切换不会致使该接口的执行结果存在二义性,也就是说咱们不用考虑同步的问题。缓存

线程安全问题都是由全局变量及静态变量引发的。安全

若每一个线程中对全局变量、静态变量只有读操做，而无写操做，通常来讲，这个全局变量是线程安全的；如有多个线程同时执行写操做，通常都须要考虑线程同步，不然的话就可能影响线程安全。多线程

安全性：并发

好比一个 ArrayList 类，在添加一个元素的时候，它可能会有两步来完成：1. 在 Items[Size] 的位置存放此元素；2. 增大 Size 的值。高并发

在单线程运行的状况下，若是 Size = 0，添加一个元素后，此元素在位置 0，并且 Size=1；性能

而若是是在多线程状况下，好比有两个线程，线程 A 先将元素存放在位置 0。可是此时 CPU 调度线程A暂停，线程 B 获得运行的机会。线程B也向此 ArrayList 添加元素，由于此时 Size 仍然等于 0 （注意哦，咱们假设的是添加一个元素是要两个步骤哦，而线程A仅仅完成了步骤1），因此线程B也将元素存放在位置0。而后线程A和线程B都继续运行，都增长 Size 的值。测试

那好，咱们来看看 ArrayList 的状况，元素实际上只有一个，存放在位置 0，而 Size 却等于 2。这就是“线程不安全”了。

安全性：

线程安全性不是一个非真即假的命题。 Vector 的方法都是同步的，而且 Vector 明确地设计为在多线程环境中工做。可是它的线程安全性是有限制的，即在某些方法之间有状态依赖(相似地，若是在迭代过程当中 Vector 被其余线程修改，那么由 Vector.iterator() 返回的 iterator会抛出ConcurrentModifiicationException)。

对于 Java 类中常见的线程安全性级别，没有一种分类系统可被普遍接受，不太重要的是在编写类时尽可能记录下它们的线程安全行为。

Bloch 给出了描述五类线程安全性的分类方法：不可变、线程安全、有条件线程安全、线程兼容和线程对立。只要明确地记录下线程安全特性，那么您是否使用这种系统都不要紧。这种系统有其局限性 -- 各种之间的界线不是百分之百地明确，并且有些状况它没照顾到 -- 可是这套系统是一个很好的起点。这种分类系统的核心是调用者是否能够或者必须用外部同步包围操做(或者一系列操做)。下面几节分别描述了线程安全性的这五种类别。

不可变

不可变的对象必定是线程安全的，而且永远也不须要额外的同步。由于一个不可变的对象只要构建正确，其外部可见状态永远也不会改变，永远也不会看到它处于不一致的状态。Java 类库中大多数基本数值类如 Integer 、 String 和 BigInteger 都是不可变的。

须要注意的是，对于Integer，该类不提供add方法，加法是使用+来直接操做。而+操做是不具线程安全的。这是提供原子操做类AtomicInteger的原。

线程安全

线程安全的对象具备在上面“线程安全”一节中描述的属性 -- 由类的规格说明所规定的约束在对象被多个线程访问时仍然有效，无论运行时环境如何排线程都不须要任何额外的同步。这种线程安全性保证是很严格的 -- 许多类，如 Hashtable 或者 Vector 都不能知足这种严格的定义。

有条件的

有条件的线程安全类对于单独的操做能够是线程安全的，可是某些操做序列可能须要外部同步。条件线程安全的最多见的例子是遍历由 Hashtable 或者 Vector 或者返回的迭代器 -- 由这些类返回的 fail-fast 迭代器假定在迭代器进行遍历的时候底层集合不会有变化。为了保证其余线程不会在遍历的时候改变集合，进行迭代的线程应该确保它是独占性地访问集合以实现遍历的完整性。一般，独占性的访问是由对锁的同步保证的 -- 而且类的文档应该说明是哪一个锁(一般是对象的内部监视器(intrinsic monitor))。

若是对一个有条件线程安全类进行记录，那么您应该不只要记录它是有条件线程安全的，并且还要记录必须防止哪些操做序列的并发访问。用户能够合理地假设其余操做序列不须要任何额外的同步。

线程兼容

线程兼容类不是线程安全的，可是能够经过正确使用同步而在并发环境中安全地使用。这可能意味着用一个 synchronized 块包围每个方法调用，或者建立一个包装器对象，其中每个方法都是同步的(就像 Collections.synchronizedList() 同样)。也可能意味着用 synchronized 块包围某些操做序列。为了最大程度地利用线程兼容类，若是全部调用都使用同一个块，那么就不该该要求调用者对该块同步。这样作会使线程兼容的对象做为变量实例包含在其余线程安全的对象中，从而能够利用其全部者对象的同步。

许多常见的类是线程兼容的，如集合类 ArrayList 和 HashMap 、 java.text.SimpleDateFormat 、或者 JDBC 类 Connection 和 ResultSet 。

线程对立

线程对立类是那些无论是否调用了外部同步都不能在并发使用时安全地呈现的类。线程对立不多见，当类修改静态数据，而静态数据会影响在其余线程中执行的其余类的行为，这时一般会出现线程对立。线程对立类的一个例子是调用 System.setOut() 的类。

当咱们查看JDK API的时候，总会发现一些类说明写着，线程安全或者线程不安全，好比说到StringBuilder中，有这么一句，“将StringBuilder 的实例用于多个线程是不安全的。若是须要这样的同步，则建议使用StringBuffer。”，提到StringBuffer时，说到“StringBuffer是线程安全的可变字符序列，一个相似于String的字符串缓冲区，虽然在任意时间点上它都包含某种特定的字符序列，但经过某些方法调用能够改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。能够在必要时对这些方法进行同步，所以任意特定实例上的全部操做就好像是以串行顺序发生的，该顺序与所涉及的每一个线程进行的方法调用顺序一致”。StringBuilder是一个可变的字符序列，此类提供一个与StringBuffe兼容的API，但不保证同步。该类被设计用做StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种状况很广泛）。若是可能，建议优先采用该类，由于在大多数实现中，它比StringBuffer要快。将StringBuilder的实例用于多个线程是不安全的，若是须要这样的同步，则建议使用StringBuffer。

　　根据以上JDK文档中对StringBuffer和StringBuilder的描述，获得对String、StringBuilder与StringBuffer三者使用状况的总结：
　　一、若是要操做少许的数据用String
　　二、单线程操做字符串缓冲区下操做大量数据StringBuilder
　　三、多线程操做字符串缓冲区下操做大量数据StringBuffer

　　那么下面手动建立一个线程不安全的类，而后在多线程中使用这个类，看看有什么效果。

public class Count {  
    private int num;  
    public void count() {  
        for(int i = 1; i <= 10; i++) {  
            num += i;  
        }  
        System.out.println(Thread.currentThread().getName() + "-" + num);
    }  
}

在这个类中的count方法计算1一直加到10的和，并输出当前线程名和总和，咱们指望的是每一个线程都会输出55。

public class ThreadTest {  
    public static void main(String[] args) {  
        Runnable runnable = new Runnable() {  
            Count count = new Count();  
            public void run() {  
                count.count();  
            }  
        };  

        for(int i = 0; i < 10; i++) {  
            new Thread(runnable).start();  
        }  
    }  
}

　　这里启动了10个线程，看一下输出结果：

Thread-0-55  
Thread-1-110  
Thread-2-165  
Thread-4-220  
Thread-5-275  
Thread-6-330  
Thread-3-385  
Thread-7-440  
Thread-8-495  
Thread-9-550

　　只有Thread-0线程输出的结果是咱们指望的，而输出的是每次都累加的，要想获得咱们指望的结果，有几种解决方案：

　　一、将Count类中的成员变量num变成count方法的局部变量；

public class Count {  
    public void count() {  
        int num = 0;  
        for(int i = 1; i <= 10; i++) {  
            num += i;  
        }  
        System.out.println(Thread.currentThread().getName() + ”-“ + num);  
    }  
}

　　二、将线程类成员变量拿到run方法中，这时count引用是线程内的局部变量；

public class ThreadTest4 {  
    public static void main(String[] args) {  
        Runnable runnable = new Runnable() {  
            public void run() {  
                Count count = new Count();  
                count.count();  
            }  
        };  
        for(int i = 0; i < 10; i++) {  
            new Thread(runnable).start();  
        }  
    }  
}

　　三、每次启动一个线程使用不一样的线程类，不推荐。

　　经过上述测试，咱们发现，存在成员变量的类用于多线程时是不安全的，不安全体如今这个成员变量可能发生非原子性的操做，而变量定义在方法内也就是局部变量是线程安全的。想一想在使用struts1时，不推荐建立成员变量，由于action是单例的，若是建立了成员变量，就会存在线程不安全的隐患，而struts2是每一次请求都会建立一个action，就不用考虑线程安全的问题。因此，平常开发中，一般须要考虑成员变量或者说全局变量在多线程环境下，是否会引起一些问题。

　　要说明线程同步问题首先要说明Java线程的两个特性，可见性和有序性。

　　多个线程之间是不能直接传递数据进行交互的，它们之间的交互只能经过共享变量来实现。拿上面的例子来讲明，在多个线程之间共享了Count类的一个实例，这个对象是被建立在主内存（堆内存）中，每一个线程都有本身的工做内存（线程栈），工做内存存储了主内存count对象的一个副本，当线程操做count对象时，首先从主内存复制count对象到工做内存中，而后执行代码count.count()，改变了num值，最后用工做内存中的count刷新主内存的 count。当一个对象在多个工做内存中都存在副本时，若是一个工做内存刷新了主内存中的共享变量，其它线程也应该可以看到被修改后的值，此为可见性。

　　多个线程执行时，CPU对线程的调度是随机的，咱们不知道当前程序被执行到哪步就切换到了下一个线程，一个最经典的例子就是银行汇款问题，一个银行帐户存款100，这时一我的从该帐户取10元，同时另外一我的向该帐户汇10元，那么余额应该仍是100。那么此时可能发生这种状况，A线程负责取款，B线程负责汇款，A从主内存读到100，B从主内存读到100，A执行减10操做，并将数据刷新到主内存，这时主内存数据100-10=90，而B内存执行加10操做，并将数据刷新到主内存，最后主内存数据100+10=110，显然这是一个严重的问题，咱们要保证A线程和B线程有序执行，先取款后汇款或者先汇款后取款，此为有序性。

高并发下线程安全的单例模式

概念：
　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。
　　单例模式有如下特色：
　　一、单例类只能有一个实例。
　　二、单例类必须本身建立本身的惟一实例。
　　三、单例类必须给全部其余对象提供这一实例。
　　单例模式确保某个类只有一个实例，并且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具备资源管理器的功能。每台计算机能够有若干个打印机，但只能有一个Printer Spooler，以免两个打印做业同时输出到打印机中。每台计算机能够有若干通讯端口，系统应当集中管理这些通讯端口，以免一个通讯端口同时被两个请求同时调用。总之，选择单例模式就是为了不不一致状态，避免政出多头。

1、懒汉式单例

//懒汉式单例类.在第一次调用的时候实例化本身   
public class Singleton {  
    private Singleton() {}  
    private static Singleton single=null;  
    //静态工厂方法   
    public static Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
    }  
}

Singleton经过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的惟一实例只能经过getInstance()方法访问。

（事实上，经过Java反射机制是可以实例化构造方法为private的类的，那基本上会使全部的Java单例实现失效。此问题在此处不作讨论，姑且掩耳盗铃地认为反射机制不存在。）

可是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下极可能出现多个Singleton实例。

要实现线程安全，有如下三种方式（都是对getInstance这个方法改造，保证了懒汉式单例的线程安全，若是你第一次接触单例模式，对线程安全不是很了解，能够先跳过下面这三小条，去看饿汉式单例，等看完后面再回头考虑线程安全的问题）：

一、在getInstance方法上加同步

public static synchronized Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
}

二、不在方法上加同步，而是在方法内部使用双重检查锁定

public static Singleton getInstance() {  
        if (singleton == null) {    
            synchronized (Singleton.class) {    
               if (singleton == null) {    
                  singleton = new Singleton();   
               }    
            }    
        }    
        return singleton;   
    }

三、静态内部类

public class Singleton {    
    private static class LazyHolder {    
       private static final Singleton INSTANCE = new Singleton();    
    }    
    private Singleton (){}    
    public static final Singleton getInstance() {    
       return LazyHolder.INSTANCE;    
    }    
}

这种比上面一、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。

2、饿汉式单例

//饿汉式单例类.在类初始化时，已经自行实例化   
public class Singleton1 {  
    private Singleton1() {}  
    private static final Singleton1 single = new Singleton1();  
    //静态工厂方法   
    public static Singleton1 getInstance() {  
        return single;  
    }  
}

饿汉式在类建立的同时就已经建立好一个静态的对象供系统使用，之后再也不改变，因此天生是线程安全的。

3、登记式单例(可忽略)

//相似Spring里面的方法，将类名注册，下次从里面直接获取。  
public class Singleton3 {  
    private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();  
    static{  
        Singleton3 single = new Singleton3();  
        map.put(single.getClass().getName(), single);  
    }  
    //保护的默认构造子  
    protected Singleton3(){}  
    //静态工厂方法,返还此类唯一的实例  
    public static Singleton3 getInstance(String name) {  
        if(name == null) {  
            name = Singleton3.class.getName();  
            System.out.println("name == null"+"--->name="+name);  
        }  
        if(map.get(name) == null) {  
            try {  
                map.put(name, (Singleton3) Class.forName(name).newInstance());  
            } catch (InstantiationException e) {  
                e.printStackTrace();  
            } catch (IllegalAccessException e) {  
                e.printStackTrace();  
            } catch (ClassNotFoundException e) {  
                e.printStackTrace();  
            }  
        }  
        return map.get(name);  
    }  
    //一个示意性的商业方法  
    public String about() {      
        return "Hello, I am RegSingleton.";      
    }      
    public static void main(String[] args) {  
        Singleton3 single3 = Singleton3.getInstance(null);  
        System.out.println(single3.about());  
    }  
}

登记式单例实际上维护了一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从Map直接返回，对于没有登记的，则先登记，而后返回。

这里我对登记式单例标记了可忽略，个人理解来讲，首先它用的比较少，另外其实内部实现仍是用的饿汉式单例，由于其中的static方法块，它的单例在类被装载的时候就被实例化了。

饿汉式和懒汉式区别

从名字上来讲，饿汉和懒汉，

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，

而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

另外从如下两点再区分如下这两种方式：

一、线程安全：

饿汉式天生就是线程安全的，能够直接用于多线程而不会出现问题，

懒汉式自己是非线程安全的，为了实现线程安全有几种写法，分别是上面的一、二、3，这三种实如今资源加载和性能方面有些区别。

二、资源加载和性能：

饿汉式在类建立的同时就实例化一个静态对象出来，无论以后会不会使用这个单例，都会占据必定的内存，可是相应的，在第一次调用时速度也会更快，由于其资源已经初始化完成，

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要作初始化，若是要作的工做比较多，性能上会有些延迟，以后就和饿汉式同样了。

至于一、二、3这三种实现又有些区别，

第1种，在方法调用上加了同步，虽然线程安全了，可是每次都要同步，会影响性能，毕竟99%的状况下是不须要同步的，

第2种，在getInstance中作了两次null检查，确保了只有第一次调用单例的时候才会作同步，这样也是线程安全的，同时避免了每次都同步的性能损耗

第3种，利用了classloader的机制来保证初始化instance时只有一个线程，因此也是线程安全的，同时没有性能损耗，因此通常我倾向于使用这一种。

什么是线程安全？

若是你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。若是每次运行结果和单线程运行的结果是同样的，并且其余的变量的值也和预期的是同样的，就是线程安全的。

或者说：一个类或者程序所提供的接口对于线程来讲是原子操做，或者多个线程之间的切换不会致使该接口的执行结果存在二义性,也就是说咱们不用考虑同步的问题，那就是线程安全的。

应用

如下是一个单例类使用的例子，以懒汉式为例，这里为了保证线程安全，使用了双重检查锁定的方式：

public class TestSingleton {  
    String name = null;  
  
        private TestSingleton() {  
    }  
  
    private static volatile TestSingleton instance = null;  
  
    public static TestSingleton getInstance() {  
           if (instance == null) {    
             synchronized (TestSingleton.class) {    
                if (instance == null) {    
                   instance = new TestSingleton();   
                }    
             }    
           }   
           return instance;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public void printInfo() {  
        System.out.println("the name is " + name);  
    }  
  
}

能够看到里面加了volatile关键字来声明单例对象，既然synchronized已经起到了多线程下原子性、有序性、可见性的做用，为何还要加volatile呢，缘由已经在下面评论中提到，

还有疑问可参考http://www.iteye.com/topic/652440
和http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

public class TMain {  
    public static void main(String[] args){  
        TestStream ts1 = TestSingleton.getInstance();  
        ts1.setName("jason");  
        TestStream ts2 = TestSingleton.getInstance();  
        ts2.setName("0539");  
          
        ts1.printInfo();  
        ts2.printInfo();  
          
        if(ts1 == ts2){  
            System.out.println("建立的是同一个实例");  
        }else{  
            System.out.println("建立的不是同一个实例");  
        }  
    }  
}

运行结果：

结论：由结果能够得知单例模式为一个面向对象的应用程序提供了对象唯一的访问点，无论它实现何种功能，整个应用程序都会同享一个实例对象。

对于单例模式的几种实现方式，知道饿汉式和懒汉式的区别，线程安全，资源加载的时机，还有懒汉式为了实现线程安全的3种方式的细微差异。