synchronized 锁死情况及运用Lock解决

给大家排个雷

synchronized占用同步对象锁死的情况，使线程一直等待。
首先我们要知道，占用同步对象，同步对象是什么？又为什么会出现锁死的情况？

打个比方，小明跟小红（代表两个线程）合伙开了间公司，现在小明跟小红都想修改这个公司的名字、法人（这两个就是同步对象），开始小明占用了（synchronized）名字对象，小红占用了法人对象，然后分别修改了公司名字跟法人，但是他们还不满意，想把另一个公司重要的属性给修改了。结果就是他们谁也不服谁，都不把手里的权力放出来，当都想要对方手里的权力。于是他们就一直等待，直到白头（甜甜蜜蜜了？）

故事听完了，上代码：

public class AThread {
    public static void main(String[] args) throws InterruptedException {
        Company setnamepower = new Company("明红有限公司", "明、红");  //设置两个对象，改变公司名称、法人的权力
        Company setleaderpower = new Company("明红有限公司", "明、红");
        Thread ming = new Thread() {
            @Override
            public void run() {
                synchronized (setnamepower) { //（1）括号     //小明先拿到了改变公司名称的权力
                    try {
                        setnamepower.setName("明明的带公司");
                        Thread.sleep(1000);          //隔了一秒，小明觉得做就要做到底好吧，我再把法人改了
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                    System.out.println("小明等待ing，得不到的一直候门口");
                    synchronized (setleaderpower) {      //于是他想占有修改法人的权力
                        setleaderpower.setLeader("明");  //但是，这时小红已经先下手为强，拿到了改变法人的权力
                        System.out.println("小明改好了公司法人");
                    }
                }   //对应（1）括号    //注意：占用修改公司名字的权力（第二个占用）一定要在占用修改公司名字的里面
            }                         //否则占用就会被释放不会有死锁的发生，线程就能顺利的运行（找这个问题找了半小时，哭了）
            };
        Thread hong = new Thread() {
            @Override
            public void run() {
                synchronized (setleaderpower) {     //小红先拿到了改变公司法人的权力
                    try {
                    setleaderpower.setLeader("红");
                        Thread.sleep(1000);       //隔了一秒，让小明有充足的时间改公司名（占用权力）
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println("小红等待ing");
                    synchronized (setnamepower) {          //小红想拿到改变公司名称的权力
                        setnamepower.setName("红红的带带公司"); //但是，这个权力还在小明手里
                        System.out.println("小红改好了公司名称");
                    }
                }
            }
        };
        ming.start();
        hong.start();
    }
}

company：

public class Company {
       String name;
       String leader;
       public Company(String name,String leader){
           this.name=name;
           this.leader=leader;
       }
    public Company(){}
    public void setName(String name) {
        this.name = name;
        System.out.println("修改后的公司名字："+name);
    }
    public void setLeader(String leader) {
        this.leader = leader;
        System.out.println("修改后的法人名字："+leader);
    }
}

运行结果：

修改后的公司名字：明明的带公司
修改后的法人名字：红
小红等待ing
小明等待ing，得不到的一直候门口

那么怎么避免这种情况的发生呢？
我们可以用Lock，强人🔒♂的锁。
synchronized是一个关键字，而lock是一个接口
看代码：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class BThread {
    public static void main(String[] args) {
        Company setname = new Company("明红有限公司", "明、红");
        Lock lock = new ReentrantLock();  //定义了一把锁
        Thread ming = new Thread() {
            boolean locked=false;
            @Override
            public void run() {
             try {
                 setname.setName("明明的带公司");
                 locked=lock.tryLock(1,TimeUnit.SECONDS); //1s占不下来就放弃，知♂而退好吧
                 Thread.sleep(2000);  //使小明有充足的时间占锁
                 if (locked){               //判断小明有没有得到锁
                     System.out.println("小明得到了锁并修改公司法人");
                     setname.setLeader("明");
                 }
             }catch (Exception e){e.printStackTrace();}
             finally{
                 if (locked){
                 lock.unlock();
             }
             }
            }
        };

        Thread hong = new Thread() {
            boolean locked=false;
            @Override
            public void run() {
                try {
                    setname.setLeader("红");
                    locked=lock.tryLock(1,TimeUnit.SECONDS);
//                    Thread.sleep(1000);
                    if (locked){
                        System.out.println("小明得到了锁并修改公司法人");
                        setname.setName("红红的带带公司");
                    }
                    else {
                        Thread.sleep(2000);   //小红后知后觉
                        System.out.println("小红没有得到锁，最后一无所有");
                    }
                }catch (Exception e){e.printStackTrace();}
                finally {
                    if (locked) {
                        lock.unlock();
                    }
                }
            }
        };
        ming.start();
        hong.start();
    }
}

运行结果：

修改后的公司名字：明明的带公司
修改后的法人名字：红
小明得到了锁并修改公司法人
修改后的法人名字：明
小红没有得到锁，最后一无所有

运用了tryLock，当一个线程占用不到同步对象之后，就会放弃，而不会吊死在一棵树上。

计算机小白。有很多不好的地方，希望大家指正。也希望这篇博客能给需要的人些许帮助。