深入解析死锁问题与线程安全：synchronized与Lock的异同及sleep()与wait()的区别

死锁问题

不同线程互相占用对方的同步资源，互不放弃。如果等待对方放弃，就会出现僵局。

死锁形成后，不会出现异常或提示，但所有线程都被阻塞，无法继续。

锁

它是同步代码方法的替代方法，是解决线程安全问题的一种方法。

同步和锁的异同

两者都是用来解决线程安全问题

区别在于：

执行代码后synchronized会自动释放监视器。

lock 手动启动同步并使用unlock() 手动释放同步。

建议先使用lock。

比较面试问题的三种方法

睡眠（）和等待（）

一旦执行这两个方法，当前线程就可以进入阻塞状态。

(1)但是两种方法使用的位置不同。

Sleep()在Thread类中声明，wait()在对象中声明

(2)调用范围或要求不同

sleep()可以在需要的时候调用

wait() 必须放在同步代码块中

(3) 是否释放同步监视器的问题

sleep() 不会释放

wait() 将

class Number implements Runnable{
    private int num =1;
    @Override
    public void run() {
        while(true){
            synchronized (this) {
                    this.notify();
                    //唤醒线程
                if(num<=100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+num);
                    num++;
                    try {
                        //使得调用该方法的线程进入阻塞
                        //使用wait 会释放线程锁
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}
public class ThreadCommunication {
    public static void main(String[] args) {
        Number num1=new Number();
        Thread t1=new Thread(num1);
        Thread t2=new Thread(num1);
        Thread t3=new Thread(num1);
        t1.setName("Thread1");
        t2.setName("Thread2");
        t1.start();
        t2.start();
    }
}