多线程中的互斥控制程序代码_Java中的并发——线程安全性

一.什么是线程安全性？

当多个线程访问某个类时，不管运行时环境采用何种调度方式，或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，则这个类是线程安全的。

二.线程安全性具体体现在哪儿？

1.原子性：提供互斥访问，同一时刻只能有一个线程对它进行操作。

java中如何体现原子性的：

Atomic包中的类主要通过CAS实现原子性

CAS的含义是：CompareAndSwap 原理是：

public final int getAndAddInt(Object var1（当前对象）,long var2（var1值的偏移量）,int var4（对象值要加的值）){
  int var5;
  do{
     var5=this.getIntVolatile(var1,var2);//获得主存中此对象的值
  }while(!this.CompareAndSwapInt(var1,var2,var5,var5+var4));//将主存中的值和当前值比较，如果相等，执行加操作，否则循环执行，直到相等

return var5;//返回
}

CAS的ABA问题：有两个线程1，2，线程1，2同时得到共享变量A，2先将其修改为B后又修改为A，1再进行CAS操作成功，但此时1中的A已经不是原来的A了。导致不安全。

通过锁来实现原子性

Java中的锁主要有两种：

1）synchronized(修饰符)：
修饰代码块：大括号括起来的代码，作用于调用此代码块的对象。
修饰方法：整个方法，作用于调用此方法的对象。

修饰静态方法：整个静态方法，作用于此类实例化的所有对象。
修饰类：括号括起的部分，作用于此类实例化的所有对象。

2)Lock锁：代码实现 ReentrantLock 它可以指定锁主的范围，例子：

private static class Buffer{

        private static final int CAPACITY=1;//缓冲区大小为1
        private LinkedList<Integer>queue=new LinkedList<>();

        //创建互斥锁
        private static Lock lock=new ReentrantLock();

        //创建条件
        private static Condition notEmpty=lock.newCondition();
        private static Condition notFull=lock.newCondition();

        public void write(int value)
        {
            lock.lock();//上锁
            try{
                while(queue.size()==CAPACITY){
                    System.out.println("Wait for notFull condition");
                    notFull.await();//令write进入等待
                }
                queue.offer(value);//添加value到queue
                notEmpty.signal();//唤醒read
            }catch(InterruptedException ex)
            {
                ex.printStackTrace();
            }
            finally{
                lock.unlock();//解锁
            }

        }

        public int read()
        {
            int value=0;
            lock.lock();//上锁
            try{
                while(queue.isEmpty())
                {
                    System.out.println("tttWait for notEmpty condition");
                    notEmpty.await();//令read进入等待
                }
                value=queue.remove();//弹出元素
                notFull.signal();//唤醒write
            }catch(InterruptedException ex)
            {
                ex.printStackTrace();
            }
            finally {
                lock.unlock();//解锁
                return value;
            }
        }
    }

java中实现原子性的三种方式对比：
Atomic:竞争激烈时能维持常态，比lock性能好，但只能同步一个值。
Synchronized:不可中断锁，适合竞争不激烈，可读性好。
Lock:可中断锁，多样化同步，灵活性强，竞争激烈时能维持常态。

2.可见性：一个线程对主内存的修改可以及时的被其他线程观察到

导致共享变量线程间不可见的原因：线程交叉执行，重排序结合线程交叉执行，共享变量更新后的值没有在工作内存与主存间及时更新

java中实现可见性：

1）synochronized:
JMM关于synchronized有两个规定：
—线程解锁前，必须把共享变量的最新值刷新到主存中。
—线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值。

2）Volatile
它主要通过加入内存屏障来禁止重排序来实现。

3.有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，观察结果一般杂乱无序。

在JMM中允许编译器和处理器对指令进行重排序，重排序的过程不会影响到单线程执行，但是它会干扰到多线程的并发执行的正确性。

java中除了volatile，synchronized，lock保证了有序性外。

JVM的原生有序性原则也在一定程度上保证了有序性：

heppens-before原则：
1）程序代码执行次序规则
2）锁写规则：一个unlock操作先行发生于后面对同一个锁的lock操作
3）volatile变量规则：对一个变量的写操作先行发生于后对此变量的读操作
4）线程执行规则

总结：线程安全性主要体现在：原子性，可见性，有序性三个方面。

结尾

感谢看到最后的朋友，都看到最后了，点个赞再走啊，如有不对之处还请多多指正。