线程安全
线程这部分太难了,难以理解,我已经摆烂了,等学完框架后再回过头来总结把
学习内容
- 线程安全
- 变量的线程安全问题
- 如何保证线程安全?
- 使用synchronized关键字(自动锁)
- 用代码理解synchronized
- 使用原子类
- 什么是原子类?
- AtomicInteger类与AtomicLong类
- AtomicBoolean类
- AtomicIntegerArray类与AtomicLongArray类
- 使用Lock(手动锁)
- synchronized和ReentrantLock区别
- Lock以下功能时synchronized不具备的
变量的线程安全问题
- 局部变量 ——> 无线程安全问题
- 实例变量 ——> 存放再堆中,存在线程安全问题
- 静态变量 ——> 存放再方法区中,存在线程安全问题
局部变量和常量不存在线程安全问题
如何保证线程安全?
使用synchronized关键字(自动锁)
1.修饰实例方法,作用于当前实例(this)加锁,进入同步代码前要获得当前实例的锁(对象锁)
语法格式:[修饰符列表] synchronized 返回值类型 方法名(参数列表)
2.修饰静态方法,作用于当前类对象(Class对象)加锁,进入同步代码块前要获得的当前类对象的锁(类锁)
语法格式:[修饰符列表] static synchronized 返回值类型 方法名(参数列表)
3.同步代码块
语法格式:synchronized (需要同步的线程之间的共享对象) {需要线程同步的代码}
对象锁:对象每个对象都有且仅有一把对象锁,100个对象有100把对象锁
类锁:每个类都有且仅有一把类锁,创建100个该类的对象也只有1把类锁
用代码理解synchronized
题目
假设1个老师,5个学生,我们来模拟一个老师给学习好的三名学生同时发10份笔记本,每次只发放一份笔记本,每个学生相当于一个线程(只给3个线程分配,剩下两个线程不分配)
通过题目看一看出:同学1、同学2、同学3这三个线程共享一个teacher对象,并且这三个线程在分书的过程要求同步,而同学4、同学5这两个线程并不共享teacher对象。
我们可以让Teacher实现Runable接口,在run方法中给分书代码加上synchronize语句块,同时将这个Teacher的实例交给同学1、同学2、同学3这三个线程(Thread)来代理(静态代理),如下图所示
具体代码如下
package com.jsoft.homework;
/**
* @author guxiangquan
* @date 2022/8/2
*/
public class Test4 {
public static void main(String[] args) {
Teacher teacher = new Teacher();
new Thread(teacher,"同学1").start(); // 同学1
new Thread(teacher,"同学2").start(); // 同学2
new Thread(teacher,"同学3").start(); // 同学3
new Thread(new Student(),"同学4").start(); // 同学4
new Thread(new Student(),"同学5").start(); // 同学5
}
}
class Student implements Runnable {
@Override
public void run() {
while(true) {
try {
Thread.sleep(800);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+ ": 我是孤儿,老师不给我发笔记本,555");
}
}
}
class Teacher implements Runnable {
private volatile int noteCount = 10;
@Override
public void run() {
boolean flag = true;
while (flag) {
flag = distribute();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public boolean distribute() {
synchronized (this) {
if(noteCount <= 0) {
return false;
}
System.out.println(Thread.currentThread().getName() + "收到一份笔记本,还剩下:" + (--noteCount) + "本");
return true;
}
}
}
编写代码时遇到的问题
使用synchronized语句块时,使用this作为共享对象,这个this是指Thread实例还是Teacher实例?想要知道this具体指向的是谁,就需要知道究竟是谁调用的run()方法。我们都知道使用start()方法会调用run()方法,由于是Thread实例调用的start(),那让我们来看一下Thread类中的源码(
Java8)
strat()中调用了start0()
在这里可以看出是target调用了run(),而trager就是我们创建Thread时候传入的Teacher,
结论:run()是由Teacher(Runnable)这个被代理类实例所调用的,而this就是传入的这个Teacher实例
上面代码中synchronized语句块中给this加锁示例图
使用原子类
什么是原子类?
Java中的原子类是java.util.concurrent.atomic包下的对象,他们之所以有原子性的共性,都来源于CAS,可见CAS的重要性。对于原子类变量的操作是不会存在并发性问题的,不需要使用同步手段进行并发控制。它底层自身的实现即可保证变量的可见性以及操作的原子性,一般我们可以使用AtomicInteger,AtomicLong等实现计数器等功能,利用AtomicBoolean实现标志位等功能。
AtomicInteger类与AtomicLong类
对于AtomicInteger、ActomicLong这两个类由于他们的方法相似,所以只需要了解AtomicInteger类的使用,便能了解ActomicLong类的使用
包路径: java.util.concurrent.atomic.AtomicInteger/AtomicLong
继承关系:AtomicInteger/AtomicLong类 —> Number类 —> Object类
构造方法
实例方法
方法 | 功能 |
void set() | 设置当前值 |
int get() | 获取当前值 |
int intValue() int longValue() int floatValue() int doubleValue | 实现Number抽象类的抽象方法 返回当前值的不同类型 |
int getAndIncrement() | 先返回当前值在自增,类似于 i++ |
int getAndDecrement() | 先返回当前值在自减,类似于 i- - |
int incrementAndGet() | 先自增再返回当前值,类似于 ++i |
int decrementAndGet() | 先自减再返回当前值,类似于 - -i |
int addAndGet(int) | 先让当前值加上参数值,再返回当前值 |
int getAndAdd(int) | 先返回当前值,再让当前值加上参数值 |
boolean compareAndSet(int expect, int update) | 判断当前值是否于expect相等, 如果相等将当前值修改为update,并且返回true, 如果不相等,并不修改当前值并且返回false |
weakCompareAndSet(int expect, int update) | 与compareAndSet()无异 |
其中所有含算数运算的方法都是原子操作
AtomicBoolean类
包路径: java.util.concurrent.actomic.AtomicBoolean
继承关系:AtomicBollean类 —> Object类
构造方法
实例方法
AtomicIntegerArray类与AtomicLongArray类
待补充…
使用Lock(手动锁)
Lock接口的实现类ReentrantLock
ReentrantLock,可重入锁
实现了Lock接口
synchronized和ReentrantLock区别
- Lock是一个接口;synchronized是一个关键字,是由底层©语言的实现
- synchronized发生异常时,会自动释放线程占用的锁不会发生死锁;Lock发生异常,若没有主动释放,极有可能占用资源不放手,而需要再finally中手动释放锁
- Lock可以让等待锁的线程中断,使用synchronized只会让等待的线程一直等待下去,不能响应中断
- Lock可以提高多个线程进行读操作的效率
Lock以下功能时synchronized不具备的
ReentrantReadWriteLock:
对于一个应用而言,一般情况下读错做远远多于写操作,如果仅仅是读的操作没有写的操作,数据又是线程安全,读写锁给我们提供了一种锁,读的时候可以很多线程一起读,但是不能由线程再写,写是独占的,当有线程再执行写的操作,其他线程既不能读,也不能写。
再某些场景下能极大提高效率
Lock锁的原理cas和aqs
synchronized是由c语言实现的,只能作为关键字来使用
java提供了一些并发的编程的包,底层原理cas和aqs