线程的同步与锁

线程的同步，为什么要线程同步？

线程并发执行时，可能会操作同一个资源（比如变量），如果线程A操作了资源，但是还没执行完，线程B又操作了资源，会引发资源数据不一致，不准确的问题。

示例：

public class Test4 {
    public static void main(String[] args) {
        TestSync testSync = new TestSync();
        Thread t1=new Thread(testSync,"t1");
        Thread t2=new Thread(testSync,"t2");
        t1.start();
        t2.start();
    }
}
class TestSync implements Runnable{
    Timer timer=new Timer();
    public void run() {
        try {
            timer.add(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class Timer{
    public static int num=0;
    public void add(String name) throws InterruptedException {
        num++;
        Thread.sleep(1);
        System.out.println("线程"+name+"是第"+num+"个执行的");
    }
}

执行结果：

线程t1是第2个执行的
线程t2是第2个执行的

分析：t1把num加一变为1，但是因为在t1执行过程中，t2也对num做了加一，所以最终num为2。
解决办法：锁住不让其他线程执行的代码块。有两种方式：

1. 使用synchronized关键字锁住代码块
   如下：

public void add(String name) throws InterruptedException {
        synchronized (this){
            num++;
            Thread.sleep(1);
            System.out.println("线程"+name+"是第"+num+"个执行的");
        }
    }

2. 使用synchronized修饰方法

public synchronized void add(String name) throws InterruptedException {
//        synchronized (this){
            num++;
            Thread.sleep(1);
            System.out.println("线程"+name+"是第"+num+"个执行的");
//        }
    }

执行结果：

线程t1是第1个执行的
线程t2是第2个执行的

同步方法跟同步代码块的区别： 同步方法是锁定this，同步代码块可以使用任何对象。

同步锁的优劣势

优势：解决了线程安全问题
劣势：性能大大降低

死锁

死锁的产生原因

当A线程锁定一个资源o1，然后去请求资源o2，B线程锁定一个资源o2，然后去情况资源o1时，两个线程相互都要索取资源，但是资源都被锁定，双方对峙，互不相让，产生死锁。

死锁示例

public class Test5 {
    public static void main(String[] args) {
        TestDeadLock t1 =new TestDeadLock();
        t1.flag=1;
        TestDeadLock t2 =new TestDeadLock();
        t2.flag=2;
        Thread tt1=new Thread(t1);
        Thread tt2=new Thread(t2);
        tt1.start();
        tt2.start();
    }
}
class TestDeadLock implements Runnable {
    public int flag = 1;
    static Object o1 = new Object();//必须为static，否则，锁住的不是同一个对象，不能形成死锁
    static Object o2 = new Object();//必须为static，否则，锁住的不是同一个对象，不能形成死锁
    public void run() {
        System.out.println("flag:" + flag);
        if (flag == 1) {
            synchronized (o1) {
                try {
                    Thread.sleep(500);//确保线程t1已经拿到锁o1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o2) {
                    System.out.println("t1");
                }
            }
        }
        if(flag==2){
            synchronized(o2){
                try {
                    Thread.sleep(5000);//确保线程t2已经拿到锁o2
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o1){
                    System.out.println("t2");
                }
            }
        }
    }
}

预防：把锁定对象的粒度尽量控制为一，防止资源相互占有。

注意：如果方法m1锁定，但是m2没有锁定，m1在执行过程中是m2是可以操作m1所占用的资源，m2在执行过程中m1也可以操作m2的资源。

如何解决死锁

1. 避免在同步代码块中调用外部的同步方法。
2. 在嵌套多层synchronized同块中，对锁进行排序，使得每次获取锁的顺序是一致的。

锁的分类

对象锁和类锁的总结