详解线程安全

最新推荐文章于 2024-06-13 08:44:35 发布

指挥部在下面

最新推荐文章于 2024-06-13 08:44:35 发布

阅读量452

点赞数

分类专栏： javaee 操作系统文章标签：安全 java jvm

本文链接：https://blog.csdn.net/weixin_61427900/article/details/130174503

版权

javaee 同时被 2 个专栏收录

24 篇文章 0 订阅

订阅专栏

操作系统

12 篇文章 0 订阅

订阅专栏

1.为什么会有线程

多进程是为了解决并发编程，更加充分利用多核CPU资源。但是进程的创建和销毁开销大，就引入了线程。一个进程包含至少一个线程，创建第一个线程的时候会分配好资源，后续在创建线程就直接共享前面的资源，节省了分配资源的开销。

2.线程不安全的可能原因

在多线程环境下代码执行出现bug的情况被称为“线程不安全”。

可能的原因如下

抢占式执行：这是线程不安全的万恶之源，多个线程在调度的时候是全随机的。这是内核实现的，咱们无能为例
多个线程修改同一个变量：有的时候能通过调整代码，来规避这个问题，但是普适性不高。

String是不可变对象，因为把set系列方法不对外公布，这就让String变成线程安全的，因为多个线程无法修改同一个变量

修改操作不是原子的：例如++操作本质上是3个cpu指令，load,add,save。CPU上是以一个指令为最小单位，不会一个指令执行到一半就让其他线程调度走。因此要想让线程安全就把这多个操作给打包成原子操作即加锁，这也是解决线程安全问题最常用的方法。

内存可见性问题：这是编译器优化导致的bug
指令重排序：这也是编译器优化导致的bug

3.如何解决线程不安全问题

咱们上面说了，解决线程不安全最常用的方法就是加锁，让操作变成原子的。加锁就类似于多个男孩子追同一个女孩子，如果男生A追到了，就会在朋友圈官宣类似于加锁，此时其他男孩子就要阻塞等待，直到这个男生分手（释放锁）。其他男生要阻塞等待是因为他们追的是同一个女生（锁发生了竞争）。当然如果是两个男生分别追两个女孩子，男生A和男生B不存在竞争，就不用阻塞等待（不存在锁竞争）。

3.1加锁的关键字synchronized

以加锁count++为例

public class Test5 {
	private static int count = 0;
	public synchronized static void increase() {
		count++;
	}
	public static void main(String[] args) throws InterruptedException {
		Thread t1 = new Thread(() -> {
			for (int i = 0; i < 50000; i++) {
				increase();
			}
		});
		Thread t2 = new Thread(() -> {
			for (int i = 0; i < 50000; i++) {
				increase();
			}
		});
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(count);
	}
}

上面的加锁操作会让并发变成串行，降低了执行效率。但是很多人有误区，以为变串行还有必要用多线程吗？上面的加锁操作只是让increse()变串行了，但是两个for循环还是并发执行，效率还是比单线程高的。

加锁过程：

加锁并不代表CPU一次性完全执行忘，中间也是会发生调度切换。但是即使t1切换走了，t2仍然是BLOCKED状态，无法在CPU上运行。这就类似于图书馆占座，人去上个厕所（调度走了）其他人想坐这个座位（有锁竞争，要阻塞等待）也没办法坐

误区：加锁了就一定线程安全

public class Test5 {
	private static int count = 0;
	public synchronized static void increase() {
		count++;
	}
	public static void increase2() {
		count++;
	}
	public static void main(String[] args) throws InterruptedException {
		Thread t1 = new Thread(() -> {
			for (int i = 0; i < 50000; i++) {
				increase();
			}
		});
		Thread t2 = new Thread(() -> {
			for (int i = 0; i < 50000; i++) {
				increase2();
			}
		});
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(count);
	}
}

t1线程调用increase()确实是加锁了，但是t2线程没调用increase2()没有加锁。只有一个线程加锁，没有锁竞争，也就不会有阻塞等待，也就不会让并发修改变成串行修改。就类似A追到女生（加锁了），但是B不讲武德，在守门员面前进球（不加锁，没阻塞等待）。

Java中锁对象是任意的

可以修饰方法，上面的代码就是锁方法
可以修饰代码块
修饰静态变量/方法

public class Test6 {
	private static int count = 0;
	static class Increase {
		public void add() {
			//代码块加锁
			synchronized (this) {//谁调用add方法，谁就是this
				count++;
			}
		}
	}
	public static void main(String[] args) throws InterruptedException {
		Increase increase = new Increase();
		Thread t1 = new Thread(() -> {
			for (int i = 0; i < 50000; i++) {
				increase.add();//this就是increase对象，针对increase对象加锁
			}
		});
		Thread t2 = new Thread(() -> {
			for (int i = 0; i < 50000; i++) {
				increase.add();//针对increase对象加锁产生锁竞争
				//如果这里是 increase2.add()那这里的this就是increase2对象，此时针对increase2加锁，两个线程针对不同对象加锁，不会产生锁竞争，锁竞争是为了其中一个线程阻塞等待，才能保证线程安全。
			}
		});
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(count);
	}
}

public class Test6 {
	private static int count = 0;
	static class Increase {
		public Object locker = new Object();
		public void add() {
			//针对locker对象加锁，locker是Increase的一个普通变量，每个Increase实例都有自己的locker实例
			synchronized (locker) {
				count++;
			}
		}
	}
	public static void main(String[] args) throws InterruptedException {
		Increase increase = new Increase();
		Thread t1 = new Thread(() -> {
			for (int i = 0; i < 50000; i++) {
				increase.add();
			}
		});
		Thread t2 = new Thread(() -> {
			for (int i = 0; i < 50000; i++) {
				increase.add();//此时的increase对象是同一个，对应的increase中的locker就是同一个对象，此时两个线程针对同一个对象加锁，仍然会存在锁竞争，就会阻塞等待。
				//如果这里是increase2对象，那么increase对象中有一个locker,increase2对象中有一个locker,两个locker不同，即两个线程针对两个对象加锁，不会发生锁竞争，线程不安全
			}
		});
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(count);
	}
}

public class Test7 {
    public static int count = 0;
    //静态内部类
    static class Increase {
        //静态成员
        private static Object locker = new Object();
        public void add() {
            //对类对象加锁
            synchronized (locker) {
                count++;
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Increase increase1 = new Increase();
        Increase increase2 = new Increase();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    increase1.add();
                }
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    increase2.add();
					//increase1和increase2虽然是两个不同的对象，但是这两个对象中的locker是类属性（唯一的），即对同一个locker加锁，产生锁竞争，会阻塞等待，线程安全
                }
            }
        };
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

public class Test8 {
    public static int count = 0;
    static class Increase{
        public void add() {
            //针对类对象加锁
            synchronized (Increase.class) {//反射
                count++;
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Increase increase1 = new Increase();
        Increase increase2 = new Increase();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    increase1.add();
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    increase2.add();//虽然是两个不同的对象，但是对同一个类对象Increase.class加锁，存在锁竞争，会阻塞等待，线程安全
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

总结：任意对象都可以在synchronized里面作为锁对象，在多线程代码中，我们不关心锁对象是谁，只关心，两个线程是否锁同一个对象，锁同一个对象才有锁竞争，才会阻塞等待；锁不同对象就没有锁竞争

3.2使用volatile解决内存可见性问题

class Counter{
    public static int count = 0;
}
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (Counter.count == 0) {

            }
            System.out.println("执行不到");
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            System.out.println("请输入一个数");
            Scanner scanner = new Scanner(System.in);
            Counter.count = scanner.nextInt();
        });
        t2.start();
        t1.join();
        t2.join();
    }
}

我们发现t2线程修改了count值，却没有输出“执行不到”，这主要怪编译器优化。
线程t1的代码中while (Counter.count == 0) 会频繁的进行load和cmp操作，其中load操作要不断的从内存中读取数据，而cmp只是在寄存器上不断进行比较，load消耗的时间长，比cmp慢了3-4个数量级。编译器就会帮你优化，既然你频繁的load，而且load结果还一样，那就只执行一次Load操作，后续进行cmp不用再重新读取内存了。在单线程环境下，这个优化是正确的，但是在多线程环境下一个线程把内存改了，但是另外一个线程感知不到，这就是内存可见性问题
解决方案：告诉编译器这个地方不要优化，即使用volatile修饰变量

JMM

他的全称是Java Memory Model,我们刚才说过volatile禁止了编译器优化，避免直接读取CPU寄存器中缓存的数据，而是每次都重新读取内存。Java设计时就是让程序员不关注硬件设备，为此Java自己搞了个JMM模型，即把CPU寄存器+缓存统称为工作内存，把物理内存称为主内存。
在JMM角度看volatile:正常程序执行的过程中，会把主内存的数据，先加载到工作内存中，再进行计算处理。编译器优化可能导致不是每次都读取主内存，而是直接读取工作内存的缓存数据，这就可能导致内存可见性问题。volatile起到的效果就是保证每次读取内存时都是真的从主内存中重新读取。

3.3使用volatile防止内存可见性问题

public Instance getInstance() {
	if(instance == null) {
		sychronized(this) {
			if(instance == null) {
				instance = new Instance();
			}
		}
	}
	return instance;
}

以new对象为例，new对象的可大致分为3个步骤：1. 申请内存，得到内存首地址；2. 调用构造方法，来初始化实例； 3. 把内存首地址赋值给instance引用。这个场景可能会导致”指令重排序“，在单线程角度下，2和3是可以调换的，执行效果一样。但是在多线程环境下如果按照1，3，2顺序执行，有可能t1线程执行了1和3之后，还没执行2之前，t2线程调用getInstance(),此时就会认为instance不为null,直接返回Instance,如果后续对Instance进行解引用就可能导致空指针异常。
为了避免指令重排序，我们可以使用volatile修饰变量,即使用volatile修饰instance