标签：sleep 获取 例子 first etl final AC 性能 oid
1.什么是线程安全
一个实例或这一个方法在多线程使用中不会出现任何问题。2.产生线程不安全的原因
多个线程访问同一相同资源，并且有线程执行了写操作，可能会出现线程安全问题。2.怎样做到类线程安全
无状态 :没有成员变量的类，也就不存在共享同一资源了。
让类不可变：所有成员变量定义为final
volatile :最轻量，保证类的可见性 但是不能保证原子性。（当这个共享资源改变时会通知其他 读取最新的）
CAS ：乐观锁
加锁：悲观锁
ThreadLocal 让每个线程工作内存里都有一个变量拷贝3.线程安全问题
死锁：多个线程（m） 竞争多个资源（n） n<=m 互不相让
如：线程1 线程2 同时需要资源A B， 1->A , 2->B。现在1需要拿B,但是B被2拿到并锁定,所以1等待2释放B，同理2和A也是这样，互相等待，谁也不放，导致死锁
a.简单顺序锁：
两个线程代码层级互相拿对方需要的不同资源
public void getFirst() {
try {
synchronized (first) {
System.out.println(Thread.currentThread().getName()+"getFirst first");
Thread.sleep(1000);
synchronized (second) {
System.out.println(Thread.currentThread().getName()+"getFirst second");
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void getSecond() {
try {
synchronized (second) {
System.out.println(Thread.currentThread().getName()+"getFirst second");
Thread.sleep(1000);
synchronized (first) {
System.out.println(Thread.currentThread().getName()+"getFirst first");
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
} b.动态顺序锁：
参数传递 导致死锁
public void transfer(UserAccounts from, UserAccounts to, int amount) {
try {
String threadName = Thread.currentThread().getName();
synchronized (from) {
System.out.println(threadName + " get " + from.getName());
Thread.sleep(100);
synchronized (to) {
System.out.println(threadName + " get " + to.getName());
from.flyMoney(amount);
to.flyMoney(amount);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
1.对于简单顺序死锁，可以改变拿锁顺序让他们一致即可。
2.对于动态锁，通过一种方式给他们指定顺序，如判断hashcode来设定拿锁顺序。
private Object tieLock = new Object();//加时锁
public void transfer(UserAccounts from, UserAccounts to, int amount) {
int fromHash = System.identityHashCode(from);//调用object hash因为哈希方法能被改写
int toHash = System.identityHashCode(to);
//始终让小的先加锁 如果相同 则再定义一个锁变量，看谁先获取到这个变量 谁先执行操作
if (fromHash < toHash) {
synchronizedSafe(from, to, from, to, amount);
} else if (toHash < fromHash) {
synchronizedSafe(to, from, from, to, amount);
} else {
synchronized (tieLock) {
synchronizedSafe(from, to, from, to, amount);
}
}
}
public void synchronizedSafe(UserAccounts first, UserAccounts sencond, UserAccounts from, UserAccounts to, int amount) {
try {
String threadName = Thread.currentThread().getName();
synchronized (first) {
System.out.println(threadName + " get " + first.getName());
Thread.sleep(100);
synchronized (sencond) {
System.out.println(threadName + " get " + sencond.getName());
from.flyMoney(amount);
to.addMoney(amount);
System.out.println(from);
System.out.println(to);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
3.采用尝试拿锁方式。 在共享对象中建立一个锁，程序中判断拿到锁再拿下一把锁，如果没有拿到就释放当前锁
//在共享变量的UserAccounts 类中定义一个锁
private final Lock lock = new ReentrantLock();
//加锁逻辑
public void transfer(UserAccounts from, UserAccounts to, int amount) {
String threadName = Thread.currentThread().getName();
Random r = new Random();
while (true) {
if (from.getLock().tryLock()) {//先拿from的锁 如果拿到尝试拿to的锁
System.out.println(threadName + " get " + from.getName());
try {
if (to.getLock().tryLock()) {
//拿到to的锁后执行操作
try {
System.out.println(threadName + " get " + to.getName());
from.flyMoney(amount);
to.addMoney(amount);
System.out.println(from);
System.out.println(to);
break;
} finally {
//发生异常释放锁
to.getLock().unlock();
}
}
} finally {
from.getLock().unlock(); //to的锁拿不到就释放掉from的锁
}
}
}
try {
//随机休眠 拿锁时间过短可能造成活锁
Thread.sleep(r.nextInt(10));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
活锁： 上述例子不加sleep可能造成活锁，线程1 拿A 线程2 拿B ,1尝试拿B,拿不到，释放掉A，2拿A拿不到，释放掉B.循环上述操作。
活锁和死锁最大的区别是，是否释放资源，死锁会一直等待，而活锁会释放掉。
线程饥饿：由于线程优先级太低导致一直无法执行该线程
性能：标签：sleep 获取 例子 first etl final AC 性能 oid
原文地址：https://www.cnblogs.com/xingluo/p/9183540.html
