线程学习（8）-变量的线程安全分析

成员变量与静态变量是否线程安全

如果它们没有被线程共享，则线程安全

如果它们被线程共享了，存在两张情况：

如果只有读操作，此时是线程安全的。

如果是读写操作，则这段代码是临界区，需要考虑线程安全。

package com.bo.threadstudy.two;

import java.util.List;

/**
 * 关于线程安全功能的验证
 */
public class ThreadSafeTest {
    public static void main(String[] args) {
        ThreadSafe threadSafe = new ThreadSafe();
        //启动俩线程，验证线程安全
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                threadSafe.test01(200);
            }).start();
        }
    }
}

/**
 * 资源类测试
 */
class ThreadSafe{
    //成员变量
    private List<Integer> list;

    public void test01(int num){
        for (int i = 0; i < num; i++) {
            test02();
            test03();
        }
    }

    private void test02(){
        list.add(1);
    }

    private void test03(){
        list.remove(0);
    }

}

结果：

看一下源码

 这里size是0。--size导致下标称为-1，造成ArraysIndexOutOfBoundsException异常。

出现这种现象的原因何在？

因为List是共享变量，在多个线程调用test02以及test03方法时，出现指令交错问题。

remove（0）指的是删除下标为0的元素。模拟一下场景。

时间片分配到thread1，此时thread1执行了add方法。

时间片分配到thread2，此时thread2执行了add方法。

但是add方法是非原子性的，很可能出现thread1得到主存中的size为0，在add之后将size+1得到1但并未写到主存的场景。而thread2在主存中得到了size为0.对size+1得到1写入到主存中。

之后thread1再次获取时间片，将自己的size=1写入到主存中

而执行remove方法时，需要执行两次remove方法，所以造成数组下标越界异常。

如果此时将list对象私有化，则不会出现问题。

package com.bo.threadstudy.two;

import java.util.ArrayList;
import java.util.List;

/**
 * 关于线程安全功能的验证
 */
public class ThreadSafeTest {
    public static void main(String[] args) {
        ThreadSafe threadSafe = new ThreadSafe();
        //启动俩线程，验证线程安全
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                threadSafe.test01(200);
            }).start();
        }
    }
}

/**
 * 资源类测试
 */
class ThreadSafe{
    //成员变量
//    private List<Integer> list = new ArrayList<>();


    public void test01(int num){
       List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            test02(list);
            test03(list);
        }
    }

    private void test02( List<Integer> list){
        list.add(1);
    }

    private void test03( List<Integer> list){
        list.remove(0);
    }

}

 这种方式不会共享List资源，所以不会出现线程安全问题。

这种方式将成员变量改为了局部变量，那么局部变量一定不会出问题吗，答案是否定的。

 

局部变量是否线程安全

局部变量是线程安全的。

但局部变量引用的对象却未必：

如果该对象没有逃离方法的作用域访问，则它是线程安全的。

如果该对象逃离了方法的作用域访问，则需要考虑线程安全。

怎么逃离这个方法呢？我继承一下这个ThreadSafe类。重写下方法。

package com.bo.threadstudy.two;

import java.util.ArrayList;
import java.util.List;

/**
 * 关于线程安全功能的验证
 */
public class ThreadSafeTest {
    public static void main(String[] args) {
        ThreadSafe threadSafe = new ThreadSafeClass();
        //启动俩线程，验证线程安全
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                threadSafe.test01(2000);
            }).start();
        }
    }
}

/**
 * 资源类测试
 */
class ThreadSafe{
    //成员变量
//    private List<Integer> list = new ArrayList<>();


    public void test01(int num){
       List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            test02(list);
            test03(list);
        }
    }

    public void test02( List<Integer> list){
        list.add(1);
    }

    public void test03( List<Integer> list){
        list.remove(0);
    }

}

/**
 * 继承ThreadSafe类，测试线程安全
 */
class ThreadSafeClass extends ThreadSafe{
    //成员变量
//    private List<Integer> list = new ArrayList<>();

    public void test03( List<Integer> list){
        new Thread(() -> {
            list.remove(0);
        }).start();
    }

}

异常如下：

这个问题是在删除的时候size和index相等，都为0的情况。这种现象是怎么发生的呢？

主线程thread1得到时间片，原先size=0，初始插入元素后，size+1,此时size=1。

新线程thread2得到时间片，对size进行-1，此时在新线程中size=0，但是并没有写入到主存，此时主存中size=1。

主存不断运行，并创建了许多个remove新线程。主存中size也累加到n。

thread2获取到时间片，将自己的size=0的这种结果写入到主存中。

然后继续调用一个remove线程任务，此时便出现了这个错误。

所以多线程对临界区发生线程安全，有很大原因是出在了没有办法将结果实时写入到主存中导致的。这个后续，了解了volatile关键字后再说。这个关键字不能修饰局部变量。

常见的线程安全类

String
Integer
StringBuffer
Random
Vector
Hashtable
java.util.concurrent 包下的类
这里说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的。也可以理解为
1. 它们的每个方法是原子的
2. 但注意它们多个方法的组合不是原子的，见后面分析

线程安全方法的组合调用

请看下面这个例子。

package com.bo.threadstudy.two;

import lombok.extern.slf4j.Slf4j;

import java.util.Hashtable;

/**
 * 线程安全的方法组合起来一块调用，是否会是线程安全的呢？
 */
@Slf4j
public class CombineThreadTest {
    public static void main(String[] args) {
        Hashtable<String, String> map = new Hashtable<>();

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                //线程安全containsKey
                if(!map.containsKey("key")){
                    //put线程安全
                    log.debug(Thread.currentThread().getName()+"进入containsKey方法中");
                    map.put("key","2");
                }
            },"t"+i).start();
        }
    }

}

很明显并没有保持线程安全。

把synchronized给加上

package com.bo.threadstudy.two;

import lombok.extern.slf4j.Slf4j;

import java.util.Hashtable;

/**
 * 线程安全的方法组合起来一块调用，是否会是线程安全的呢？
 */
@Slf4j
public class CombineThreadTest {
    public static void main(String[] args) {
        Hashtable<String, String> map = new Hashtable<>();

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                //线程安全containsKey
                synchronized (map){
                    if(!map.containsKey("key")){
                        //put线程安全
                        log.debug(Thread.currentThread().getName()+"进入containsKey方法中");
                        map.put("key","2");
                    }
                }

            },"t"+i).start();
        }
    }

}

 

所以在使用线程安全方法的时候也需要注意组合的情况，组合这种场景不保证原子性。