Java线程安全

时间:2022-06-03 Pretend.. 人气:0

一、线程安全（重点）

1、线程安全概念

在多线程的情况下，需要考虑多个线程并行并发执行：此时多个线程之间的代码是随机执行的。如果多线程环境下代码的运行结果是符合我们的预期的，即在单线程情况下应该的结果，则这个程序是线程安全的。

2、产生线程不安全的情况

多个线程共享变量的操作：

都是读操作时，使用值进行判断，打印等操作（不存在线程安全问题）
存在线程进行了写操作（存在线程安全问题）

3、线程不安全的原因

（1）原子性：多行指令是最小的执行单位（不可拆分），就具有原子性。如果不满足原子性，则存在线程安全问题。

一条java语句不一定是原子的：

如n++、n--，是有三步组成：从内存读取到cpu寄存器、修改数据、再写回到cpu；
Object o=new Object()，也涉及到三个步骤：申请内存、初始化对象、赋值。

以上列举的虽然只是一条java语句，但是其不具有原子性。

（2）可见性：一个线程对共享变量的修改，能够及时的被其他线程看见。多个线程并发并行执行，使用各自的工作内存，互相之间不可见（不具有可见性）。

Java内存模型（JMM）：

目的是屏蔽掉各种硬件和操作系统的内存访问差异，以实现Java程序在各种平台下都能达到一致的并发效果。

线程之间的共享变量存在主内存；
每一个线程都有自己的工作内存；
当程序要读取一个共享变量时，会先将变量从主内存拷贝到工作内存，再从工作内存读取数据；
当程序要修改一个共享变量时，会先修改工作内存中的副本，再同步到主内存。

（3）代码顺序性/有序性：

代码重排序：

比如，以下代码：

1、去前台取U盘，

2、回教室写一会作业，

3、去前台取快递

在单线程的情况下，JVM、cpu会对其进行优化，1→3→2，这样会提高效率，这样就叫做代码重排序。

代码重排序的前提是：保证逻辑不发生改变。

4、如何解决线程不安全问题

设计多线程代码原则：满足线程安全的前提下，尽可能地提高效率

（1）对共享变量的写操作，可以加锁来保证线程安全：

Java中加锁的两种方式：

synchronized关键字：申请对给定的Java对象，对象头加锁；
Lock：是一个锁的接口，它的实现类提供了锁这样的对象，可以调用方法来加锁/释放锁。

对共享变量的写操作，不依赖任何共享变量，也可以使用volatile关键字来保证线程安全。

（2）对共享变量的读操作，使用volatile关键字就可以保证线程安全

volatile关键字：修饰变量，变量的读操作，本身就保证了原子性，volatile的作用是保证可见性和有序性，这样就可以保证线程安全。

二、synchronized关键字

synchronized本质上是修饰指定对象的对象头去。使用角度来看，synchronized必须搭配一个具体的对象来使用。

1、使用

（1）修饰普通方法：锁TestDemo对象

//方法一
public class TestDemo {
    public synchronized void methond() {
    }
}
//方法二
public class TestDemo {
    public  void methond() {
        synchronized(this){
        }
    }
}

（2）修饰静态方法：锁TestDemo对象

//方法一
public class TestDemo {
    public synchronized static void method() {
    }
}
//方法二
public class TestDemo {
    public static void method() {
        synchronized(TestDemo.class){
        }
    }
}

2、特性

（1）互斥

synchronized会起到同步互斥的作用，某个线程执行到某个对象的synchronized中时，如果其他线程也执行到同一个对象synchronized时会阻塞等待。

进入synchronized修饰的代码块，相当于加锁；
退出synchronized代码块，相当于释放锁。

互斥可以满足原子性，

（2）刷新内存

synchronized结束释放锁，会把工作内存中的数据刷新到主存中；其他线程申请锁时，获取的始终是最新的数据。（满足可见性）。

（3）有序性

某个线程执行一段同步代码，不管如何重排序，过程中不可能有其他线程执行的指令，这样多个线程执行同步代码，就满足一定的顺序。

（4）可重入

同一个线程，可以多次申请同一个对象锁（可重入）

三、volatile关键字

修饰某个变量（实例变量，静态变量）

1、保证可见性

代码在写入volatilt修饰的变量时：

改变线程工作内存中volatile变量副本的值
将改变后的副本的值从工作内存中刷新到主存中

代码在读取volatile修饰的变量时：

从主存中读取volatile变量的最新值到工作内存中
从工作内存中读取副本值

2、禁止指令重排序

建立内存屏障，保证代码有序性。

3、不保证原子性

synchronized和volatile有着本质区别。synchronized可以保证原子性，volatile保证的是内存的可见性。

只能在共享变量的读操作以及常量赋值操作时使用（这些操作本身就具有原子性）

四、wait和notify（线程间的通信）

线程通信：线程间通信，就是一个线程以通知的方式，唤醒某些等待的线程（或者让当前线程等待），这样就可以让线程通过通信的方式具有一定的顺序性。

1、wait()方法

wait做的事情：

使当前执行代码的线程进入等待状态（把线程放到等待队列中）
释放当前的锁
满足一定条件时，重新尝试获取这个锁

wait结束等待的条件：

其他线程调用该对象的notify方法
wait等待时间超时（wait提供了一个带一个参数的方法，可以指定等待时间）
其他线程调用该等待线程的interrupted方法，导致wait抛出InterruptedException异常

wait要搭配synchronized来使用。脱离synchronized使用wait会直接抛异常。

如下：

Object object = new Object();
    synchronized (object) {
        object.wait();
    }
//这种情况下线程会一直等待下去，这个时候需要使用notify来唤醒

2、notify()和notifyAll()方法

notify方法只是唤醒某一个等待的线程，使用notifyAll方法可以一次性唤醒所有的等待线程。

notify()也是在同步方法中调用，用来通知其他等待的线程，对其发出通知notify，并使它们重新获取该对象的对象锁；
如果有多个线程在等待，则有线程调度器随机挑选出一个处于等待状态的线程；
notify()方法执行后，当前线程不会立马释放该对象锁，要等到当前线程将程序执行完，退出同步代码块后才会释放对象锁。

【注】

虽然notifyAll()同时唤醒所有处于等待状态的线程，但是这些线程需要竞争锁。所以并不是同时执行，仍然是有先后顺序的执行。

3、wait和sleep的对比

一个是用于线程之间的通信，一个是让线程阻塞一段时间。

wait需要搭配synchrionzed使用，sleep不用
wait是Object的方法，sleep是Thread的静态方法

五、线程和进程的比较

1、线程的优点

创建线程的代价比创建进程小得多
与进程切换相比，线程切换需要操作系统做的事少得多
线程占用的资源比进程少
能充分利用多个处理器，提高效率
在等待I/O操作结束的同时，程序可执行其他的计算任务
I/O密集型操作，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作
计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现

2、线程和进程的区别

进程是进行资源分配的最小单位，线程是程序执行的最小单位
进程有自己的内存地址空间，线程只独享指令流执行的必要资源，如寄存器和栈
同一个进程的各线程之间共享内存和文件资源，可以不通过内核进行直接通信
线程的创建、切换、销毁效率更高

加载全部内容