20.线程安全

2019-12-10 本文已影响0人雪关马不前

线程安全

概念：当多线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为可以获得正确的结果，那这个对象是线程安全的。

Java语言中的线程安全

按照线程安全的“安全程度”由强至弱来排序，可以将Java语言中各种操作共享的数据分为以下5类：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。

不可变：不可变的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施。主要包括：基本类型用final修饰，String,以及java.lang.Number的部分子类（Long,Double,,BigInteger和BigDecimal等大数据类型），但原子类AtomicInteger和AtomicLong并非不可变。
绝对线程安全：不管运行环境如何，调用者都不需要任何额外的同步措施。
相对线程安全：相对线程安全就是我们通常意义上所讲的线程安全，它需要保证对这个对象单独的操作是线程安全的，我们在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。在Java语言中，大部分的线程安全类都属于这种类型，例如Vector、HashTable、Collections的synchronizedCollection()方法包装的集合等。
线程兼容：线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API大部分的类都属于线程兼容的，如与前面的Vector和HashTable相对应的集合类ArrayList和HashMap等。
线程对立：线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于Java语言天生就具备多线程特性，线程对立这种排次多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。

线程安全的实现方法

互斥同步：互斥同步是常见的一种并发正确性保障手段。同步是指在多个线程并发访问共享数据时，保证共享数据在同一时刻只被一个线程使用。而互斥是实现同步的一种手段，临界区、互斥量和信号量都是主要的互斥实现方式。因此，在这4个字里面，互斥是因，同步是果；互斥是方法，同步是目的。最基本的互斥同步手段就是 ==synchronized== 。

synchronized 关键字经过编译后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令，这两个字节码都需要一个reference类型的参数来指明锁要锁定和解锁的对象。如果Java程序中的synchronized明确指定了对象参数，那就是这个对象的reference；如果没有明确指定，那就根据synchronized就是的是实例方法还是类方法，去取对应的对象实例或Class对象来作为锁对象。
在执行monitorenter指令时，首先尝试获取对象的锁。如果这个对象没有被锁定，或者当前线程已经有用了那个对象的锁，把锁的计数器加1，相应的，在执行monitorexit指令会将锁计数器减1，当计数器为0时，锁释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另一个线程释放为止。
除了synchronized之外，还可以使用重入锁（ReentrantLock）来实现同步，在基本用法上，RentrantLock与synchronized很相似，他们都具备一样的线程重入特性，只是代码写法上有点区别，一个表现为API层面的互斥锁（Lock（）和unlock方法配合try/finally语句块来完成）。另一个表现为原生语法层面的互斥所。不过，相比synchronized，ReentrantLock增加了一些高级功能，主要有以下3项：等待可中断、可实现公平锁、以及锁可以绑定多个条件。
demo

public class MyBlockQueue<E> {
    private int size;
    private E[] blockArr;
    private static final int DEFAULT_SIZE = 5;
    ReentrantLock reentrantLock = new ReentrantLock();
    Condition notFull = reentrantLock.newCondition();//队列已满
    Condition notEmpty = reentrantLock.newCondition();//队列未满
    List<E> linkList = new LinkedList<>();

    public MyBlockQueue() {
        this.size = DEFAULT_SIZE;
    }

    public MyBlockQueue(int size) {
        this.size = size;
    }

    public boolean inQueue(E obj) {
        reentrantLock.lock();
        try {
            while (this.size == linkList.size()) {
                System.out.println("队列满了，等待消费！当前队列长度："+linkList.size());
                notFull.await();
            }
            linkList.add(obj);
            System.out.println("入队" + obj.toString());
            notEmpty.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
        return true;
    }

    public E outQueue() {
        reentrantLock.lock();
        E e;
        try {
            while (linkList.size() == 0) {
                try {
                    System.out.println("队列为空！等着！");
                    notEmpty.await();
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
            e = linkList.remove(0);
            notFull.signal();
            return e;
        } catch (Exception e1) {
            e1.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
        return null;
    }

    public static void main(String[] args) {
        MyBlockQueue<String> stringMyBlockQueue = new MyBlockQueue<>(100);
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 0;

                while (true) {
                    i += 1;
                    stringMyBlockQueue.inQueue("" + i);
                }
            }
        });
        t.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    String str = stringMyBlockQueue.outQueue();
                    System.out.println(str);
                }
            }
        });
        t2.start();
    }
}

非阻塞同步：互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程征用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采取其他补偿措施（最常见的补偿措施就是不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步。

使用乐观并发策略需要“硬件指令集的发展”才能进行。因为我们需要操作和冲突检测两个步骤具备原子性，需要靠硬件来完成这件事，硬件保证一个从语义上看起来需要多次操作的行为只通过一条处理器指令就能完成，这类指令常用的有：
测试并设置(Test-and-Set)
获取并增加(Fetch-and-Increment)
交换(Swap)
比较交换(Compare-and-swap,简称CAS)
加载连接/条件存储(Load-Linked/Store-Conditional,简称LL/SC)

CAS指令需要3个操作数，分别是内存位置（在Java中可以简单理解为变量的内存地址，用V表示）、旧的预期值（用A表示）和新值（用B表示）。CAS指令执行时，当且仅当V符合旧预期值A时，处理器用新值B更新V的值，否则它就不执行更新，但是无论是否更新了V的值，都会返回V的旧值，上述的处理过程是一个原子操作。

在Java程序中。sun.misc.Unsafe类里面的compareAndSwapInt()和compareAndSwapLong()等几个方法包装提供，虚拟机内部对这些方法做了特殊处理，即时编译出来的结果就是一条平台相关的处理器CAS指令，没有方法调用的过程，或者可以认为无条件内联进去了。

ABA问题

CAS从语义上来说并不是完美的，存在这样的一个逻辑漏洞：如果一个变量V初次读取的时候是A值，并且在准备赋值的时候检查到它仍然为A值，那我们不能说它的值没有被其他贤臣改变过，因为在这期间它的值曾经被改成了B，后来又被改回为A，那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的"ABA"问题。J.U.C包为了解决这个问题，提供了一个带有标记的原子引用类“AtomicStampedReference”,它可以通过控制变量的版本来保证CAS的正确性。

无同步方案：要保证线程安全，并不一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性和手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。比如以下这几种：

可重入代码：这种代码也叫做纯代码，可以在代码执行的任何时刻终端塔，转而去执行另一段代码（包括递归调用它本身），而控制权返回后，原来的程序不会出现任何错误。总结一点，就是不依赖存储在堆上的数据和公共的系统资源、用到的状态量都有参数中传入、不调用非可冲入的方法等。
线程本地存储：如果一段代码所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行？如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样无须同步也能保证线程之间不出现数据争用的问题。

20.线程安全

线程安全

Java语言中的线程安全

线程安全的实现方法

ABA问题

猜你喜欢

热点阅读