当多个线程访问某个类,不管运行时环境采用何种调度方式或者这些线程如何交替执行,并且在主调代码中不需 要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类为线程安全的。----《并发编程实战》 什么是线程不安全? 多线程并发访问时,得不到正确的结果。
编译命令:
javac -encoding UTF-8 UnSafeThread.java
将class文件反编译为字节码:
javap -c UnSafeThread.class
0: getstatic #2 获取指定类的静态域,并将其押入栈顶
3: iconst_1 将int型1押入栈顶
4: iadd 将栈顶两个int型相加,将结果押入栈顶
5: putstatic #2 为指定类静态域赋值
8: return
image
例子中,产生线程不安全问题的原因: num++ 不是原子性操作,被拆分成好几个步骤,在多线程并发执行的 情况下,因为cpu调度,多线程快递切换,有可能两个同一时刻都读取了同一个num值,之后对它进行+1操 作,导致线程安全性。
一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断,要么就都不执行。
A想要从自己的帐户中转1000块钱到B的帐户里。那个从A开始转帐,到转帐结束的这一个过程,称之为一个事务。在这个事务里,要做如下操作: 从A的帐户中减去1000块钱。如果A的帐户原来有3000块钱,现在就变成2000块钱了。
在B的帐户里加1000块钱。如果B的帐户如果原来有2000块钱,现在则变成3000块钱了。如果在A的帐 户已经减去了1000块钱的时候,忽然发生了意外,比如停电什么的,导致转帐事务意外终止了,而此时B的帐 户里 还没有增加1000块钱。那么,我们称这个操作失败了,要进行回滚。回滚就是回到事务开始之前的状 态,也就是回到A的帐户还没减1000块的状态,B的帐户的原来的状态。此时A的帐户仍然有3000块,B的帐 户仍然有 2000块。
通俗点讲:操作要成功一起成功、要失败大家一起失败如何把非原子性操作变成原子性
volatile关键字仅仅保证可见性,并不保证原子性 synchronize关机字,使得操作具有原子性
<font color="#000066"> 每个java对象都可以用做一个实现同步的锁,这些锁称为内置锁</font> 线程进入同步代码块或方法的时候会自动获得该锁,在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。
<font color="#000066">内置锁是一个互斥锁,这就是意味着最多只有一个线程能够获得该锁,</font>当线程A尝试去获得线程B持有的内置锁时,线程A必须等待或者阻塞,直到线程B释放这个锁,如果B线程不释放这个锁,那么A线程将永远等待下去。 修饰普通方法:锁住对象的实例 修饰静态方法:锁住整个类 修饰代码块: 锁住一个对象 synchronized (lock) 即synchronized后面括号里的内容
public class SynDemo {
/**
* 不要用synchronized修饰静态方法 因为他是锁住的整个类
*/
// public synchronized void out() throws InterruptedException {
// Thread.sleep(5000L);
// System.out.println(Thread.currentThread().getName());
// }
private Object lock = new Object();
public void out() throws InterruptedException {
synchronized(lock){
Thread.sleep(1000L);
System.out.println(Thread.currentThread().getName());
}
}
public static void main(String[] args) {
SynDemo synDemo = new SynDemo();
SynDemo synDemo2 = new SynDemo();
new Thread(()->{
try {
synDemo.out();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(()->{
try {
synDemo2.out();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
能且仅能修饰变量 保证该变量的可见性,volatile关键字仅仅保证可见性,并不保证原子性 <font color="#000066">禁止指令重排序</font> A、B两个线程同时读取volatile关键字修饰的对象,A读取之后,修改了变量的值,修改后的值,对B线程来说, 是可见 使用场景
/**
* volatile
* 1:作为线程开关 2:单例,修饰对象实例,禁止指令重排序
*/
public class VolatileDemo implements Runnable {
private static volatile boolean flag = true;
@Override
public void run() {
while (flag){
System.out.println(Thread.currentThread().getName());
}
}
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new VolatileDemo());
thread.start();
Thread.sleep(1000L);
flag=false;
}
}
饿汉式--本身线程安全 在类加载的时候,就已经进行实例化,无论之后用不用到。如果该类比较占内存,之后又没用到,就白白浪费 了资源。
/**
* 饿汉式单例
* 本身就是线程安全的
*/
public class HungerSingleton {
private static HungerSingleton ourInstance = new HungerSingleton();
public static HungerSingleton getInstance() {
return ourInstance;
}
private HungerSingleton() {
}
public static void main(String[] args) {
HungerSingleton hungerSingleton = new HungerSingleton();
for (int i = 0; i < 10; i++) {
new Thread(() -> {
System.out.println(HungerSingleton.getInstance());
}).start();
}
}
}
懒汉式 -- 最简单的写法是非线程安全的 在需要的时候再实例化
/**
* 懒汉式单例 线程安全的写法
*/
public class LazySingleton {
//这里一定要使用volatile,可以禁止指令重排序
private static volatile LazySingleton lazySingleton = null;
private LazySingleton() {
}
public static LazySingleton getInstance() {
//判断实例是否为空,为空才实例化
if (lazySingleton == null) {
//模拟实例化耗时操作
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (LazySingleton.class) {
if (lazySingleton == null) {
lazySingleton = new LazySingleton();
}
}
}
// 否则直接返回
return lazySingleton;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
System.out.println(LazySingleton.getInstance());
}).start();
}
}
}
线程安全性问题成因
打破成因中三点任意一点
1:多线程环境--将多线程改单线程(必要的代码,加锁访问)
2:多个线程操作同一共享资源--不共享资源(ThreadLocal、不共享、操作无状态化、不可变)
3:对该共享资源进行了非原子性操作-- 将非原子性操作改成原子性操作(加锁、使用JDK自带的原子性操作的类、JUC提供的相应的并发工具类)