Java多线程(4)-线程的死锁及lock

线程的死锁问题

死锁

• 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃
  自己需要的同步资源，就形成了线程的死锁
• 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于
  阻塞状态，无法继续

例：

public class Thread03 {
    public static void main(String[] args) {
        StringBuffer s1=new StringBuffer();
        StringBuffer s2= new StringBuffer();
        //使用匿名方式来创建对象
        new Thread(){
            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();
        //使用实现Runnable接口的形式来实现
        new Thread(new Runnable() {
            @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();
    }
}

运行结果：

发生死锁，程序既不报错也无法结束

产生死锁的原因：当线程一开始执行拿到锁s1发生阻塞，cpu去执行线程二，而线程二拿到锁s2后也发生阻塞，这是根据同步锁的机制，没有执行完所有同步代码，锁是不会释放的，所以线程一需要s2，而线程二需要s1，二个线程都不会释放自己所占有的锁，所以产生死锁。

解决方法

• 专门的算法、原则
• 尽量减少同步资源的定义
• 尽量避免嵌套同步

Lock(锁)

class win implements Runnable{
    private int ticket=100;
    private ReentrantLock lock =new ReentrantLock();
    public void run(){
        while (true){
            try {
                //调用lock方法
                lock.lock();
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ": 售票" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }finally {
                //3.解锁
                lock.unlock();
            }
        }
    }
}
public class Locktest {
    public static void main(String[] args) {
        win w=new win();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized 与 Lock的异同：

• 相同：二者都可以解决线程安全问题
• 不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
  Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

优先使用顺序：

• Lock ----->同步代码块（已经进入了方法体，分配了相应资源)----->同步方法（在方法体之外）