多线程(五):解决线程不安全方案
Posted 头发都哪去了
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了多线程(五):解决线程不安全方案相关的知识,希望对你有一定的参考价值。
多线程(五):解决线程不安全方案
线程不安全原因 | 解决方案 |
---|---|
①CPU抢占 执行(万恶之源) | 无法解决 |
②代码非原子性 | 在关键代码处,让使用的CPU排队执行(加锁) |
③(内存)不可见 | 可使用 volatile 关键字 |
④编译器/代码优化(指令重排序) | 可使用 volatile 关键字 |
⑤多个线程同时修改了同一个变量 | 不通用,修改难度大 |
volatile关键字
volatile 关键字 轻量级解决线程不安全的方案
代码示例如下:
public class ThreadDemo29
private static volatile boolean flag = false;
public static void main(String[] args)
Thread t1 = new Thread(new Runnable()
@Override
public void run()
while (!flag)
System.out.println("终止执行");
);
t1.start();
Thread t2 = new Thread(new Runnable()
@Override
public void run()
try
Thread.sleep(1000);
catch (InterruptedException e)
e.printStackTrace();
System.out.println("设置flag = true");
flag = true;
);
t2.start();
该代码执行结果为:
我们发现,此代码与上篇博客中的ThreadDemo27的代码基本相同,就是在就是在定义全局变量 flag 时,添加了 volatile 关键字,通过解决内存不可见的方法,解决了线程不安全的问题。
volatile 作用:
①禁止指令重排序
②解决线程可见性的问题,实现原理:当操作完变量之后,强制删除掉线程工作内存中的此变量。
注意:
volatile 关键字,无法解决多线程非原子性问题。
public class ThreadDemo30
static class Counter
//定义私有变量
private volatile int num = 0;
//定义任务执行次数
private final int maxSize = 100000;
//num++
public void incrment()
for (int i = 0; i < maxSize; i++)
num++;
//num--
public void decrment()
for (int i = 0; i < maxSize; i++)
num--;
public int getNum()
return num;
public static void main(String[] args) throws InterruptedException
Counter counter = new Counter();
Thread t1 = new Thread(() ->
counter.incrment();
);
t1.start();
Thread t2 = new Thread(() ->
counter.decrment();
);
t2.start();
t1.join();
t2.join();
System.out.println("最终执行结果:" + counter.getNum());
代码执行结果:
可见,volatile 关键字,无法解决多线程非原子性问题,进而无法解决线程非安全。
锁操作
Java中解决线程安全操作(锁的操作)
1.使用 synchronized 关键字来加锁和释放锁【JVM层面的解决方案,自动帮我们进行加锁和释放锁的操作】
2.Lock 手动锁【Java层面的解决方案,需要程序员自己去加锁和释放锁】
公平锁与非公平锁
公平锁可以按顺序进行执行,而非公平锁执行的效率更高。在Java中所有锁默认的策略都是非公平锁。
synchronized 的锁机制是非公平锁。
Lock 默认的锁策略也是非公平锁,但是 Lock 也可以声明为公平锁。
锁操作的关键步骤
1.尝试获取(如果成功拿到锁,加锁,进行排队等待)
2.释放锁
synchronized 的使用
synchronized的底层是使用操作系统的mutex lock实现的。
1.当线程释放锁时,JMM会把该线程对应的工作内存中的共享变量刷新到主内存中
2.当线程获取锁时,JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须从主内存中读取共享变量
synchronized用的锁是存在Java对象头里的。
synchronized同步快对同一条线程来说是可重入的,不会出现自己把自己锁死的问题;
同步块在已进入的线程执行完之前,会阻塞后面其他线程的进入。
程序的关键操作加锁,示例代码如下:
public class ThreadDemo31
//全局变量
private static int number = 0;
//定义循环次数
private static final int maxSize = 100000;
public static void main(String[] args) throws InterruptedException
//创建锁
Object lock = new Object();
//线程1:自增10W次
Thread t1 = new Thread(new Runnable()
@Override
public void run()
for (int i = 0; i < maxSize; i++)
//实现加锁操作
synchronized (lock)
number++;
);
t1.start();
//线程2:自减10W次
Thread t2 = new Thread(new Runnable()
@Override
public void run()
for (int i = 0; i < maxSize; i++)
synchronized (lock)
number--;
);
t2.start();
//等待线程1和线程2执行完毕
t1.join();
t2.join();
System.out.println("最终执行结果:" + number);
注意事项:在进行加锁操作的时候,同一组业务必须为共同的锁对象。
该代码的执行结果如下:
我们发现,此程序就是线程安全的。
synchronized 实现原理:
1.操作:互斥锁 mutex
2.JVM:帮我们实现的监视器锁的加锁和释放锁的操作
3.Java:
a) 锁对象 mutex
b) 锁存放的地方:变量的对象头
synchronized 在 JDK 6 之前,使用重量级锁实现的,性能非常低,所以用到的并不多。
JDK 6 对 synchronized 做了优化(锁升级 )
synchronized 的使用场景:
1.使用 synchronized 来修饰代码块 (加锁对象可以自定义)
上述 ThreadDemo31 就是 synchronized 来修饰代码块的使用场景
2.使用 synchronized 来修饰静态方法,示例如下:
public class ThreadDemo35
//全局变量
private static int number = 0;
//定义循环次数
private static final int maxSize = 100000;
public static synchronized void incrment()
for (int i = 0; i < maxSize; i++)
number++;
public static synchronized void decrment()
for (int i = 0; i < maxSize; i++)
number--;
public static void main(String[] args) throws InterruptedException
//线程1:自增10W次
Thread t1 = new Thread(new Runnable()
@Override
public void run()
incrment();
);
t1.start();
//线程2:自减10W次
Thread t2 = new Thread(new Runnable()
@Override
public void run()
decrment();
);
t2.start();
//等待线程1和线程2执行完毕
t1.join();
t2.join();
System.out.println("最终执行结果:" + number);
该代码的执行结果:
我们发现,使用synchronized 来修饰静态方法,也能使该程序线程安全。
3.使用 synchronized 可以用来修饰普通方法(加锁对象是当前类的实例),示例如下:
public class ThreadDemo35
//全局变量
private static int number = 0;
//定义循环次数
private static final int maxSize = 100000;
// public static synchronized void incrment()
public synchronized void incrment()
for (int i = 0; i < maxSize; i++)
number++;
// public static synchronized void decrment()
public synchronized void decrment()
for (int i = 0; i < maxSize; i++)
number--;
public static void main(String[] args) throws InterruptedException
ThreadDemo35 threadDemo35 = new ThreadDemo35();
//线程1:自增10W次
Thread t1 = new Thread(new Runnable()
@Override
public void run()
threadDemo35.incrment();
);
t1.start();
//线程2:自减10W次
Thread t2 = new Thread(new Runnable()
@Override
public void run()
threadDemo35.decrment();
);
t2.start();
//等待线程1和线程2执行完毕
t1.join();
t2.join();
System.out.println("最终执行结果:" + number);
该代码的执行结果:
我们发现,使用synchronized 来修饰普通方法,也能使该程序线程安全。
Lock 的使用
Lock 的使用,示例代码如下:
public class ThreadDemo32
//全局变量
private static int number = 0;
//定义循环次数
private static final int maxSize = 100000;
public static void main(String[] args) throws InterruptedException
//1.创建手动锁
Lock lock = new ReentrantLock();
//线程1:自增10W次
Thread t1 = new Thread(new Runnable()
@Override
public void run()
for (int i = 0; i < maxSize; i++)
//2.加锁
lock.lock();
try
number++;
finally
//3.释放锁
lock.unlock();
);
t1.start();
//线程2:自减10W次
Thread t2 = new Thread(new Runnable()
@Override
public void run()
for (int i = 0; i < maxSize; i++)
lock.lock();
try
number--;
finally
lock.unlock();
);
t2.start();
//等待线程1和线程2执行完毕
t1.join();
t2.join();
System.out.println("最终执行结果:" + number);
注意事项:一定要把 lock( ) 放在 try 外面,原因如下:
1.如果将1ock()方法放在 try 里面,那么当 try 里面的代码出现异常之后,那么就会执行 finally 里面的释放锁的代码,但这个时候加锁还没成功,就去释放锁。
2.如果将 lock( ) 方法放在try里面,那么当执行 finally 里面释放锁的代码的时候就会报错(线程状态异常),释放锁的异常会覆盖掉业务代码的异常报错,从而增加了排除错误成本。
演示:将 lock( ) 方法放入 try 里面,示例代码如下:
public class ThreadDemo33
public static void main(String[] args)
Lock lock = new ReentrantLock();
try
int num = 1 / 0;//异常业务
lock.lock();
finally
lock.unlock();
该代码的执行结果如下:
我们发现,该程序执行时会报错,且异常类型为锁操作异常,并非业务异常信息。
如果将lock()方法放在try的外面,示例代码如下:
public class ThreadDemo33
public static void main(String[] args)
Lock lock = new ReentrantLock();
lock.lock();
try
int num = 1 / 0;//异常业务
finally
lock.unlock();
该代码的执行结果如下:
我们发现:异常类型为我们预期的业务异常类型。
Lock 声明公平锁示例代码如下:
public class ThreadDemo34
public static void main(String[] args) throws InterruptedException
//声明一个公平锁
Lock lock = new ReentrantLock(true);
//业务逻辑处理:打印AABBCCDD
//公共任务
Runnable runnable = new Runnable()
@Override
public void run()
for (char item : "ABCD".toCharArray())
lock.lock();
try
System.out.print(item);
finally
lock.unlock();
;
Thread t1 = new Thread(runnable, "t1");
Thread t2 = new Thread(runnable, "t1");
Thread.sleep(10);
t1.start();
t2.start();
该代码执行结果为:
Lock 的使用场景:只能用来修饰代码块。
小结
volatile 和 synchronized 有什么区别?
- volatile 可以解决内存可见性问题和禁止指令重排序,但 volatile 不能解决原子性问题;
- synchronized 可以解决任何关于线程安全的问题(关键代码排队执行,始终只有一个线程会执行加锁操作;原子性问题…)
synchronized 和 Lock 有什么区别?
- synchronized 既可以修饰代码块,又可以修饰静态方法和普通方法;而 Lock 只能修饰代码块。
- synchronized 只有非公平锁的锁策略,而 Lock(ReentrantLock) 默认也是非公平锁策略,也可以通过构造函数声明成公平锁。
- 使用 Lock(ReentrantLock) 更加灵活(比如 tryLock )。
- synchronized 是自动加锁释放锁的,而 Lock(ReentrantLock) 需要程序员来加锁和手动释放锁的。
死锁问题
基本概念
线程和锁的关系(一对多):一个线程可以拥有多把锁;但是一个锁只能被一个线程拥有。
定义:在多线程编程中(两个或两个以上的线程),因为资源抢占,造成线程无限等待的问题。
死锁问题,示例代码:
public class ThreadDemo36
public static void main(String[] args)
//创建锁A(资源A)
Object lockA = new Object();
//创建锁B(资源B)
Object lockB = new Object();
Thread t1 = new Thread(new Runnable()
@Override
public void run()
//线程1得到锁A
synchronized (lockA)
System.out.println("线程t1得到了锁A");
try 以上是关于多线程(五):解决线程不安全方案的主要内容,如果未能解决你的问题,请参考以下文章
Java并发多线程编程——集合类线程不安全之HashMap的示例及解决方案