当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些线程将如何交替执行,并且在调用代码中不需要任何额外的同步或者协同,这个类都能表现出正确的行为,那么就称这个类是线程安全的。
如何实现呢?
线程封闭
实现好的并发是一件困难的事情,所以很多时候我们都想躲避并发。避免并发最简单的方法就是线程封闭。什么是线程封闭呢?
就是把对象封装到一个线程里,只有这一个线程能看到此对象。那么这个对象就算不是线程安全的也不会出现任何安全问题。
栈封闭
栈封闭是我们编程当中遇到的最多的线程封闭。什么是栈封闭呢?简单的说就是局部变量。多个线程访问一个方法,此方法中的局部变量都会被拷贝一份到线程栈中。所以局部变量是不被多个线程所共享的,也就不会出现并发问题。所以能用局部变量就别用全局的变量,全局变量容易引起并发问题。
TheadLocal
ThreadLocal是实现线程封闭的最好方法。ThreadLocal内部维护了一个Map,Map的key是每个线程的名称,而Map的值就是我们要封闭的对象。每个线程中的对象都对应着Map中一个值,也就是ThreadLocal利用Map实现了对象的线程封闭
无状态的类
没有任何成员变量的类,就叫无状态的类,这种类一定是线程安全的。
如果这个类的方法参数中使用了对象,也是线程安全的吗?比如:
当然也是,为何?因为多线程下的使用,固然user这个对象的实例会不正常,但是对于StatelessClass这个类的对象实例来说,它并不持有UserVo的对象实例,它自己并不会有问题,有问题的是UserVo这个类,而非StatelessClass本身。
让类不可变
让状态不可变,加final关键字,对于一个类,所有的成员变量应该是私有的,同样的只要有可能,所有的成员变量应该加上final关键字,但是加上final,要注意如果成员变量又是一个对象时,这个对象所对应的类也要是不可变,才能保证整个类是不可变的。
但是要注意,一旦类的成员变量中有对象,上述的final关键字保证不可变并不能保证类的安全性,为何?因为在多线程下,虽然对象的引用不可变,但是对象在堆上的实例是有可能被多个线程同时修改的,没有正确处理的情况下,对象实例在堆中的数据是不可预知的。
加锁和CAS
我们最常使用的保证线程安全的手段,使用synchronized关键字,使用显式锁,使用各种原子变量,修改数据时使用CAS机制等等。
死锁
是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。
举个例子:A和B去按摩洗脚,都想在洗脚的时候,同时顺便做个头部按摩,13技师擅长足底按摩,14擅长头部按摩
这个时候A先抢到14,B先抢到13,两个人都想同时洗脚和头部按摩,于是就互不相让,扬言我死也不让你,这样的话,A抢到14,想要13,B抢到13,想要14,在这个想同时洗脚和头部按摩的事情上A和B就产生了死锁。怎么解决这个问题呢?
第一种,假如这个时候,来了个15,刚好也是擅长头部按摩的,A又没有两个脑袋,自然就归了B,于是B就美滋滋的洗脚和做头部按摩,剩下A在旁边气鼓鼓的,这个时候死锁这种情况就被打破了,不存在了。
第二种,C出场了,用武力强迫A和B,必须先做洗脚,再头部按摩,这种情况下,A和B谁先抢到13,谁就可以进行下去,另外一个没抢到的,就等着,这种情况下,也不会产生死锁。
所以总结一下:
1、死锁是必然发生在多操作者(M>=2个)争夺多个资源(N>=2个,且N<=M)才会发生这种情况。很明显,单线程自然不会有死锁,只有B一个去,不要2个,打十个都没问题;单资源呢?只有13,A和B也只会产生激烈竞争,打得不可开交,谁抢到就是谁的,但不会产生死锁。
2、争夺资源的顺序不对,如果争夺资源的顺序是一样的,也不会产生死锁;
3、争夺者对拿到的资源不放手。
简单顺序死锁代码
package cn.wang.safe.dl;
/**
*@author Mark老师 图灵学院 https://www.tulingxueyuan.cn/
*
*类说明:演示死锁的产生
*/
public class NormalDeadLock {
private static Object No13 = new Object();//第一个锁
private static Object No14 = new Object();//第二个锁
//第一个拿锁的方法
private static void zhouYuDo() throws InterruptedException {
String threadName = Thread.currentThread().getName();
synchronized (No13){
System.out.println(threadName + " get No13");
Thread.sleep(100);
synchronized (No14){
System.out.println(threadName + " get No14");
}
}
}
//第二个拿锁的方法
private static void monkeyDo() throws InterruptedException {
String threadName = Thread.currentThread().getName();
synchronized (No13){
System.out.println(threadName + " get No13");
Thread.sleep(100);
synchronized (No14){
System.out.println(threadName + " get No14");
}
}
}
//子线程,代表周瑜老师
private static class ZhouYu extends Thread{
private String name;
public ZhouYu(String name) {
this.name = name;
}
@Override
public void run() {
Thread.currentThread().setName(name);
try {
zhouYuDo();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
//主线程,代表Monkey老师
Thread.currentThread().setName("Monkey");
ZhouYu zhouYu = new ZhouYu("ZhouYu");
//System.out.println(ManagementFactory.getRuntimeMXBean().getName());
zhouYu.start();
monkeyDo();
}
}
动态顺序死锁
package cn.wang.safe.dl;
/**
* @author :Mark老师
* @description :不自知的死锁
*/
public class DynDeadLock {
private static Object No1 = new Object();//第一个锁
private static Object No2 = new Object();//第二个锁
/*公共业务方法*/
private static void businessDo(Object first,Object second) throws InterruptedException {
String threadName = Thread.currentThread().getName();
synchronized (first){
System.out.println(threadName + " get first");
Thread.sleep(100);
synchronized (second){
System.out.println(threadName + " get second");
}
}
}
//子线程,代表周瑜老师
private static class ZhouYu extends Thread{
private String name;
public ZhouYu(String name) {
this.name = name;
}
@Override
public void run() {
Thread.currentThread().setName(name);
try {
businessDo(No1,No2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
//主线程,代表Monkey老师
Thread.currentThread().setName("Monkey");
ZhouYu zhouYu = new ZhouYu("ZhouYu");
zhouYu.start();
businessDo(No2,No1);
}
}