这里将会系统的讲一遍我们在JAVA使用过程中学到的所有的锁，先简单给大家介绍一下有那些锁：

对象锁

this锁

类锁

定义

锁就是把对象看成锁，只有拿到锁的线程才能够对锁里面的代码块进行操作，其他线程即使拿到了执行资格和执行权限，必须等到锁被释放后争夺锁的使用权限才能进去锁的内部代码块

对象锁

格式：

synchronized(对象)
｛
            共享数据代码块操作          
｝

这里举一个线程通信的例子帮助大家理解

线程通信：简单来说就是两个线程对同一资源进行输入和输出操作

public class sharedResource {
    String Message;
    String name;
}
//对共享区域中的数据进行赋值----存数据
public class Input implements Runnable{
    sharedResource s;
    Input (sharedResource s)
    {
        this.s=s;
    }
    public void run() {
        s.name="周志华";
        s.Message="花书";
        System.out.println(s.name+"------>"+s.Message);
    }

}
//对共享区域中的数据进行取数据----也就是把数据中的数据进行置空
public class Output implements Runnable{
    sharedResource s;
    Output (sharedResource s)
    {
        this.s=s;
    }
    public void run() {
        s.name=" ";
        s.Message=" ";
        System.out.println(s.name+"------>"+s.Message);
    }
}
public class TestDemo {

    public static void main(String[] args) {
        sharedResource s=new sharedResource();
        Input i=new Input(s);
        Output o=new Output(s);
        Thread t1=new Thread(i);
        Thread t2=new Thread(o);
        t1.start();
        t2.start();
    }
}

自行多打印几次，可以发现数据会出现混乱
我们来找到操作共享数据代码块，分别是：

public void run() {
        s.name=" ";
        s.Message=" ";
        System.out.println(s.name+"------>"+s.Message);
    }

和

public void run() {
        s.name="周志华";
        s.Message="花书";
        System.out.println(s.name+"------>"+s.Message);
    }

修改一下：

    public void run() {
        synchronized(s) {
            s.name=" ";
            s.Message=" ";
            System.out.println(s.name+"------>"+s.Message);
        }
    }
    public void run() {
        synchronized(s)
        {
            s.name="周志华";
            s.Message="花书";
            System.out.println(s.name+"------>"+s.Message);
        }
    }

这里的对象其实随意用就行，我们仅仅是把它当作一个唯一的锁，但是关键

锁必须是同一个

类锁

其实我更加愿意把它称为静态锁，原因在于它是针对静态方法的，然后静态方法又是操作静态变量
格式:

synchronized(字节代码块)
｛
            共享数据代码块操作          
｝

见代码：

//对共享区域中的数据进行赋值----存数据
public class Input implements Runnable{
    static sharedResource s;//静态对象
    Input (sharedResource s)
    {
        this.s=s;
    }
    static void put() {//静态方法
        s.name="周志华";
        s.Message="花书";
        System.out.println(s.name+"------>"+s.Message);
    }
    public void run() {
        synchronized(sharedResource.class)//静态锁
        {
            put();
        }
    }

}
//对共享区域中的数据进行取数据----也就是把数据中的数据进行置空
public class Output implements Runnable{
    static sharedResource s;
    Output (sharedResource s)
    {
        this.s=s;
    }
    static void put() {
        s.name=" ";
        s.Message=" ";
        System.out.println(s.name+"------>"+s.Message);
    }
    public void run() {
        synchronized(sharedResource.class) {
            put();
        }
    }
}

类锁的根本原因就是在于这里put()是静态方法，静态方法如果把对象拿来作为锁，就会出现可能对象还未创建，但是静态方法已经执行了。显然，这不合时，于是才产生了类锁。

this锁

本质就是synchronized（x）需要传入this，也就是当前对象作为锁。
格式：

void function()
{
            synchronized(this){
                      操作共享数据代码块；
            }
}

可以对该格式进行修改，也就是把synchronized和函数名并列，即：

synchronized void function()
{
         操作共享数据代码块；
}

两种写法均正确
就是针对多个线程对同一对象进行操作的情况，这里写一个多线程卖票系统，根据这个例子来，会更加清楚，见代码

public class Ticket implements Runnable{
    private int num=1000;
    Object obj=new Object();
    synchronized void function() {
        System.out.println(Thread.currentThread().getName()+"剩余------->"+(num--));
    }
    public void run() {
        synchronized(obj){//确保票不会出现负数
            while(num>0)
                //this.function();
                function(); 
        }
    }

}
public class stasticTestDemo {

    public static void main(String[] args) {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        Thread t4=new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

这里来分析一下，我们建了4个线程来对同一对象进行卖票操作，在Ticket类中用了两个锁，一个对象锁，来操作共享数据代码块，从而来确保数据的准确性，不会出现负数情况。

对于this锁，本质在于function()方法的调用者就是this，我们锁住的就是this

死锁

JAVA锁机制在使用的时候也要防止锁会出现新的问题----死锁

死锁指的是多个对象对有限资源进行抢夺，从而形成的一种循环等待僵持的状态。本质就是在于对象众多，而资源有限，从而形成循环等待的情况

死锁的四个条件

持有请求：自己持有了资源并且继续抢夺

循环等待：形成了一个循环等待的圈子，简而言之：A请求B中持有的资源，B请求C中持有的资源，C又持有A中持有的资源，从而形成了一个循环等待的圈子

不可剥夺：资源不可以被随意剥夺

互斥条件：资源非共享，限于单独使用

直接上代码

//死锁案例,获得this锁再申请对象锁
//获得了对象锁再申请this锁
public class deadLock {
    Object obj=new Object();//对象锁

    
    int flag=0;
    void show() {//this锁
        if(flag%2==0)
        {
            synchronized(this) {
                System.out.println("if this锁");
                synchronized(obj)
                {
                    System.out.println("if obj锁");
                }
            }
        }
        else
        {
            synchronized(obj)
            {

                System.out.println("else obj锁");
                synchronized(this)
                {
                    System.out.println("else this锁");
                }
            }
        }
        flag++;
    }
    
}

public class student implements Runnable{
    deadLock d=new deadLock();
    student(deadLock d)
    {
        this.d=d;
    }
    public void run() {
        while(true)
        d.show();
    }
    
}

public class TestDemo {
    public static void main(String[] args) {
        deadLock d =new deadLock();
        student s1=new student(d);
        student s2=new student(d);
        Thread t1=new Thread(s1);
        Thread t2=new Thread(s2);
        t1.start();
        t2.start();
    }
}

我们按着死锁的定义来分析一下
s1获得了其中一个锁会紧接着继续申请另外一个锁，恰好另外一个锁很有可能正在s2中，同时s2会继续申请s1中的锁，形成了循环等待队列，形成一种僵持状态，即死锁

总结

锁分成三种，类锁，针对静态方法。对象锁，以某一具体对象作为锁。this锁，本质在于调用方法的对象是this（当前对象），所以我们可以简化把synchronized和方法名并列。