线程的安全问题
多个线程同时访问一个资源(变量、代码块、数据等),可能出现线程同步问题。
多个线程的执行是抢占式的,一个线程在执行一系列程序指令中途时,就被其它线程抢占,可能导致数据状态出现问题。
解决方式:锁机制
锁机制
synchronized 关键字,实现锁机制,可以用于修饰方法或代码块,提升数据的安全性,降低性能。
synchronized的原理:
通过监视器(monitor)完成
当对方法或一段代码上锁后,会启动监视器对这段代码监控,监视器中有计数器,当计数器为0时,允许线程进入,线程进入后,计数器加1,其它线程访问时,计数器不为0,不允许线程进入,线程执行完代码块后,计数器减1为0 ,监视器允许其它线程进入。
同步方法
当第一个线程进入方法后,自动上锁,其它线程访问不了,前面线程执行完方法后,自动释放锁,其它线程就可以访问。
public synchronized 修饰符 方法名(...){
...
}
同步代码块
synchronized(锁对象){
....
....
}
锁对象的要求:
1.任意的Java对象都可以作为锁
2. 不能是局部变量
疑问:同步方法和同步代码块的区别?
解答:
1.语法不同,一个写在方法上,一个写在方法内部
2.锁粒度不同,同步方法作用于整个方法,同步代码块作用于一段代码
3.性能不同,同步方法低于同步块
4.锁对象不同,同步方法是固定的,静态就是类.class,非静态的就是this
同步代码块可以指定锁对象。
手写一个简单的线程安全的单例模式
/**
* 懒汉式
*/
public class LazySingleton {
//创建一个锁对象
private static Lock lock = new ReentrantLock();
//2.定义静态实例 加volatile的目的是禁止指令重排,从而得到一个没有初始化的对象
private static volatile LazySingleton singleton = null;
//1.私有的构造方法
private LazySingleton() {
System.out.println("懒汉式创建对象");
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//3.静态方法创建对象并返回
public synchronized static LazySingleton getInstance() {
//双检索,DCL double check lock
//提升性能,不为空,就不执行同步代码块
if(singleton==null){
//同步代码块
synchronized (LazySingleton.class){
//判断是否为空,再创建,整体执行
if(singleton==null){
singleton = new LazySingleton();
}
}
}
return singleton;
}
}
同步锁
在并发包 java.concurrent.lock下存在大量的锁
Lock接口
常用的方法:
lock() //上锁
unlock() //解锁
常见的实现类:
ReentrantLock //重入锁
ReadLock //读锁
WriterLock //写锁
简单应用:
//构造方法如果带参数,表示是否是公平锁
Lock lock = new ReentrantLock(); //成员变量
//方法内:
try{
lock.lock();
同步的代码
}finally{
lock.unlock();
}
公平锁和非公平锁的区别?
公平锁:等待锁时间长的线程,更容器获得锁。
非公平锁:等待锁时间长和短的线程,获得锁几率相同。
synchronized和同步锁的区别?
上锁:synchronized是自动上锁和解锁,同步锁是手动完成的。
性能:同步锁的性能高于synchronized。
使用:synchronized使用简单,功能单一,同步锁提供更多方法,使用灵活。
粒度: 同步方法 > 同步块/同步锁
性能: 同步锁 > 同步块 > 同步方法
方便: 同步方法 > 同步块 > 同步锁
手写一个简单的线程死锁案例
/**
* 线程死锁案例
* 有两个线程,两个锁,线程A持有锁B,需要锁A;线程B持有锁A,需要锁B;
*/
public class DieLock {
private static Lock a = new ReentrantLock();
private static Lock b = new ReentrantLock();
public void testA() throws InterruptedException {
synchronized (a){
System.out.println(Thread.currentThread().getName()+"有a锁,需要b锁");
Thread.sleep(300);
synchronized (b){
System.out.println(Thread.currentThread().getName()+"有a锁,b锁");
}
}
}
public void testB() throws InterruptedException {
synchronized (b){
System.out.println(Thread.currentThread().getName()+"有b锁,需要a锁");
Thread.sleep(300);
synchronized (a){
System.out.println(Thread.currentThread().getName()+"有a锁,b锁");
}
}
}
public static void main(String[] args) {
DieLock dieLock = new DieLock();
new Thread(()->{
try {
dieLock.testA();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(()->{
try {
dieLock.testB();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
volatile关键字
线程同步有三大特性:
1.原子性(一系列指令要么全部执行,要么全部不执行)。
2.可见性(线程中的数据修改后,其它线程也可以读取最新的数据)。
3.有序性(线程中的指令按顺序执行,不会出现乱序)。
volatile用于修饰成员变量,保证变量的可见性和有序性。
原子性
一段代码作为整体执行,不会被其它线程打断,可以通过锁机制保证。
可见性
多线程的执行过程中,每个线程有自己的工作内存,线程会从主内存中加载数据到工作内存中,修改工作内存的数据后,其它线程是看不到最新的数据的,直到线程将新数据写回到主内存为止,中间存在线程间数据不一致的问题。
解决方法:变量前加volatile
变量前加上volatile,保证可见性,线程在修改此变量时,是在主内存中直接进行修改,其它线程马上可以看到,不存在数据不一致的情况。
有序性
cpu为了提高程序执行的效率,可能对指令顺序进行重排,volatile可以禁止指令重排。
synchronized和volatile的区别
修饰的对象:synchronized修改代码块或方法,volatile只能修饰变量。
保证的特性:synchronized保证原子性、可见性;volatile不能保证原子性,保证可见性和有序性。
性能:volatile是轻量级的线程同步方式,性能更高。
原子类
并发包中提供了一系列原子类,可以保证数据操作的原子性。这里简单举一个AtomicInteger原子整数的例子。
/**
* 原子类
*/
public class AtomicDemo {
private static int count =0;
//原子整数
private static AtomicInteger atomicInteger = new AtomicInteger(0);
public static void main(String[] args) {
for (int i = 0; i < 10000 ; i++) {
new Thread(()->{
//1.加载count值
//2.计算count++
//3.将新的值传给count
// count++;
//原子自增
atomicInteger.getAndIncrement();
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(count);
System.out.println(atomicInteger.intValue());
}
}
乐观锁和悲观锁的区别?
悲观锁:比较悲观,认为线程同步问题会经常出现,倾向于给资源上锁。
乐观锁:比较乐观,认为线程同步问题不会常出现,不给资源上锁,通过其它方式解决。
版本号机制,对数据设置版本,每次修改后版本会更新,修改后将版本和前面版本进行比较,相同就提交,不同就不提交。
CAS机制,CompareAndSwap:通过内存偏移量获得数据的原始值,通过原始值计算出预期的值,将预期的值和实际的值进行比较,相同就更新,否则就不更新进入循环等待状态,直到比较相等。
如果线程的竞争比较激烈,应该使用悲观锁。线程竞争不强的时候,使用乐观锁。