线程安全的懒汉式_死锁-ReentrantLock的使用
解决单例模式中的懒汉式的线程安全问题
解决单例模式中的懒汉式的线程安全问题
> 饿汉式：不存在线程安全问题。
> 懒汉式：存在线程安全问题，（需要使用同步机制来处理）
package thread.demo04_threadsafemore.singleton;
//实现线程安全的懒汉式
import oop.demo07.B;
public class BankTest {
static Bank b1 = null;
static Bank b2 = null;
public static void main(String[] args) {
Thread t1 = new Thread(){
@Override
public void run() {
b1 = Bank.getInstance();
}
};
Thread t2 = new Thread(){
@Override
public void run() {
b2 = Bank.getInstance();
}
};
t1.start();
t2.start();
//这一段t1/t2.join(),为了让分线程先执行，因为这还是在主线程里面
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(b1);
System.out.println(b2);
System.out.println(b1 == b2);
}
}
class Bank{
private Bank(){}
private static volatile Bank instance = null;
//实现线程安全的方式1：
// public static synchronized Bank getInstance(){ //同步监视器，默认为Book.class,类就加载一次，是唯一的
// if (instance == null){
//
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//
// instance = new Bank();
// }
// return instance;
// }
//实现线程安全的方式2：
// public static Bank getInstance(){ //同步监视器，默认为Book.class,类就加载一次，是唯一的
// synchronized(Bank.class){
// if (instance == null){
//
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//
// instance = new Bank();
// }
// return instance;
// }
// }
//实现线程安全的方式3：相较于方式1和方式2来讲，效率更高。为了避免出现指令重排，需要将instance声明为volatile
public static Bank getInstance() {
if (instance == null) {
synchronized (Bank.class) {
if (instance == null) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
instance = new Bank();
}
}
}
return instance;
}
}
单例模式饿汉式和懒汉式区别
死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程死锁。
【小故事】
面试官：你能解释清楚什么是死锁，我就录取你！
面试者：你录取我，我就告诉你什么是死锁！
……
恭喜你，面试通过了
一旦出现死锁，整个程序既不会发生异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。
举例：
package thread.demo04_threadsafemore.deadlock;
public class DeadLockTest {
public static void main(String[] args) {
StringBuilder s1 = new StringBuilder();
StringBuilder s2 = new StringBuilder();
new Thread(){
@Override
public void run() {
synchronized (s1) {
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2) {
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(){
@Override
public void run() {
synchronized (s2) {
s1.append("c");
s2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1) {
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
}
}
诱发死锁的原因：
- 互斥条件
- 占用且等待
- 不可抢夺（或不可抢占）
- 循环等待
以上4个条件，同时出现就会触发死锁。
死锁
解决死锁：
死锁一旦出现，基本很难人为干预，只能尽量规避。可以考虑打破上面的诱发条件。
针对条件1：互斥条件基本上无法被破坏。因为线程需要通过互斥解决安全问题。
针对条件2：可以考虑一次性申请所有所需的资源，这样就不存在等待的问题。
针对条件3：占用部分资源的线程在进一步申请其他资源时，如果申请不到，就主动释放掉已经占用的资源。
针对条件4：可以将资源改为线性顺序。申请资源时，先申请序号较小的，这样避免循环等待问题。
ReentrantLock（可重入锁）的使用
除了使用synchronized同步机制处理线程安全问题之外，还可以使用jdk5.0提供的Lock锁的方式
1. 步骤：
（1）创建Lock的实例，需要确保多个线程共用同一个Lock实例！需要考虑将此对象声明为static final。
（2）执行lock方法，锁定对共享资源的调用。
（3）unlock()的调用，释放对共享数据的锁定。
static final ReentrantLock lock = new ReentrantLock();
l.lock();
try {
//需要被同步的代码（操作共享数据的代码）
} finally {
l.unlock();
}
2. 面试题：
synchronized同步的方式 与Lock的对比？
synchronized不管是同步代码块还是同步方法，都需要在结束一对{}之后，释放对同步监视器的调用。
Lock是通过两个方法控制需要被同步的代码，更灵活一些。
Lock作为接口，提供了多种实现类，适合更多更复杂的场景，效率更高。
举例：
package thread.demo04_threadsafemore.lock;
//使用继承Thread类的方式，实现卖票。
import java.util.concurrent.locks.ReentrantLock;
public class LockTest {
public static void main(String[] args) {
SaleTicket1 s1 = new SaleTicket1("窗口1");
SaleTicket1 s2 = new SaleTicket1("窗口2");
SaleTicket1 s3 = new SaleTicket1("窗口3");
s1.start();
s2.start();
s3.start();
}
}
class SaleTicket1 extends Thread{
public SaleTicket1() {
}
public SaleTicket1(String name) {
super(name);
}
static int ticket = 100;//没有static直接300张票，每个窗口都卖1——100
//一个对象一份的是实例变量。
//所有对象一份的是静态变量。
//1. 创建Lock的实例，需要确保多个线程共用同一个Lock实例！需要考虑将此对象声明为static final。
private static final ReentrantLock lock = new ReentrantLock();//几个线程共用同一个lock，就用static,同上
@Override
public void run() {
while (true){
try {
//2. 执行lock方法，锁定对共享资源的调用。
lock.lock();
if (ticket > 0) { //这一块就是需要被同步的代码（操作共享数据的代码），前面和后面用lock.lock(); 和lock.unlock();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "票号为： " + ticket);
ticket--;
} else {
break;
}
}finally {
//3. unlock()的调用，释放对共享数据的锁定。
lock.unlock();//为了能够解锁，就要确保他必须执行，可以用try{}finally{},如果没有，就不会停止
}
}
}
}
ReentrantLock的基本使用&常用方法
ReentrantLock详解
