JAVA-线程安全性

线程安全性:

一个类是线程安全的是指在被多个线程访问时,类能够持续进行正确的行为.不用考虑这些线程运行时环境下的调度和交替.

 

编写正确的并发程序的关键在于对共享的,可变的状态进行访问管理.

解决方案有两种:

1.控制资源访问.经过锁机制来对资源的访问进行排队.这样来避免一个线程修改其余线程正在使用的对象

2.要确保当一个线程修改了对象的状态后,其余的线程可以真正知道这种变化.

 

资源访问控制

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

1. 无状态的类确定是线程安全的,由于它不会存在交替的状况.由于全部要用到的资源都是经过参数传进去的.这样就不会存在多个线程共享资源的问题.

 

2.若是是 有状态的类,好比它有个属性是long count;它有个方法,是让它自增:count++; http://blog.sina.com.cn/s/blog_5f54f0be0100vwh8.html此文中已经介绍了该操做并发的风险.在代码中该操做看起来是一个单独的操做,但它其实是由三个操做组成的.因此它不是 单独的,不可分割的.即:" 原子性".原子性不能指程序上的最基本的数字逻辑操做,而是逻辑上的不可分割的操做.

 

JAVA提供了一些线程安全的类,也就是实现了原子性的类.对这些类的操做是原子性的.它们是 在:java.util.concurrent.atomic包中.好比有类:AtomicLong,它是Long的原子化类.咱们对long类型的 count进行自增操做时,不是原子性的,但对AtomicLong调用:incrementAndGet()便是原子操做的,JAVA为咱们解决了这些 问题.

 

同时,JAVA提供了咱们本身可控制的原子机制-- 锁.

JAVA提供了强制原子性的内置锁机制:synchronized .

咱们经过 synchronized 给一个类,或一个方法或一个属性或一串操做进行锁标识.线程进入synchronized 以前会自动得到锁;在正常退出,或出现异常时,线程都会释放锁.被锁上后,其它线程只有等到锁被释放才能进入.不然只有一直等下去.因此这种作法在有些时候会极端影响效率.(静态属性或方法的锁是从Class对象上获取的)

当一个线程请求其余线程已经占有的锁时,请求被阻塞.但占有锁的那个线程是能够再次请求的.这就意味着:锁的基于线程的而不是基于请求.实现这种机制是为 每一个锁关联一个请求计数和一个占有它的线程.当计数为0时,表示该锁未被占有.此时线程请求时,JVM将记录锁的占有线程,并将请求计数加1.若是同一线 程再次请求这个锁,计数再加1.每次退出synchronized 标识的块时计数会减1.当计数为0时,锁被释放.

并非全部的数据都须要锁保护--只有那些被多个线程访问的可变数据才须要.过多的synchronized 会影响性能.因此咱们最好是将一些须要同步的原子操做放在同步块中.以下面这种作法:

synchronized (this) {

            ++hits;

            if (i.equals(lastNumber)) {

                ++cacheHits;

                factors = lastFactors.clone();

            }

        }

        if (factors == null) {

            factors = factor(i);

            synchronized (this) {

                lastNumber = i;

                lastFactors = factors.clone();

            }

        }

如上所示.两个分离的synchronized 块中都只有很简短的代码.第一个块保护着检查再运行的操做以检查对咱们很重要的状态码,另外一个进行数据的更新.

 

共享对象

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

同步的可见性:

使用了synchronized进行加锁后,一个线程在该同步块内作的操做对接下来的线程是可见的.这就是"同步"的含义.

1.当一个读线程和一个写线程同时进行时,咱们不能保证读线程能及时地读取写线程写入的值.除非使用synchronized进行同步.例以下面代码所示:

private static boolean ready;

    private static int number;

    private static class ReaderThread extends Thread {

        public void run() {

            while (!ready)

                Thread.yield();

            System.out.println(number);

        }

    }

    public static void main(String[] args) {

        new ReaderThread().start();

        number = 42;

        ready = true;

    }

上面的mian主线程运行时还充当了"写线程",而且新建"读线程"并让它运行.读线程会不断的循环直到ready的值为true.但在有些状况下,上面的程序会和咱们想象的输入42相异:

因为JAVA的"重排序"机制(JVM:只要代码顺序改变对结果不产生影响,那么就不能保证代码执行的顺序是书写的顺序)可能在对number设置值前ready的值就已是true了.那么输入的结果会是0.

2.在没有同步时,咱们可能就象上面同样,得到到的数据不是最新设置进去的.如:一个类有一属性,而且有它的getter,setter方法,当两个线程一个执行getter一个执行setter时,就容易出现得到到" 过时数据".但给getter,setter方法加上synchronized 后能够解决这一问题.

 

除了过时数据,还可能出现错数据,这种问题只是存在于64位的数据.因为JVM的运算是基于32位的.即:不论是布尔值(1位),short(16位),运算时,都经过左侧补零将它扩展成32位,而后进行运算.而float,double,long 等64位的数据则被作为两个32位数进行运算.

因此,在多线程未同步时,64位数据的读取可能会返回一个值的前32位,及另外一个值的后32位.经过给值加上 volatile标记可让JVM避免这种问题.如:volatile float test;

 

当一个域声明为volatile 类型后,编译器与运行时会监视这个变量,并且对它的操做不会与其余的内在操做重排序.它不会缓存在寄存器或者缓存在其它地方,因此读一个volatile 类型的变量时,它老是返回由某一线程所写入的最新值.咱们能够将它看作轻量级的同步机制.

 private int value;

     public synchronized int get() {

        return value;

    }

     public synchronized void set(int value) {

        this.value = value;

    }

如上代码能够被:volatile private int value;以及不加同步声明的getter,setter方法所代替.但固然会牺少量功能:加锁能够保证可见性和原子性,但volatile变量只能保证可见性.因此,在不须要原子性的时候,能够用它.