如果它们没有被线程共享，则线程安全
如果它们被线程共享了，存在两张情况：
如果只有读操作，此时是线程安全的。
如果是读写操作，则这段代码是临界区，需要考虑线程安全。
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 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 list = new ArrayList<>();
public void test01(int num){
List list = new ArrayList<>();
for (int i = 0; i < num; i++) {
test02(list);
test03(list);
}
}
private void test02( List list){
list.add(1);
}
private void test03( List 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 list = new ArrayList<>();
public void test01(int num){
List list = new ArrayList<>();
for (int i = 0; i < num; i++) {
test02(list);
test03(list);
}
}
public void test02( List list){
list.add(1);
}
public void test03( List list){
list.remove(0);
}
}
class ThreadSafeClass extends ThreadSafe{
//成员变量
// private List list = new ArrayList<>();
public void test03( List 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 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 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();
}
}
}
所以在使用线程安全方法的时候也需要注意组合的情况，组合这种场景不保证原子性。
