Java 中对象锁和类锁的区别？ 关键字 Synchronized的用法？

一  对象锁和类锁的关系

/*
 *
 对象锁和【类锁】 全局锁的关系？
        对象锁是用于对象实例方法，或者一个对象实例上的   this
        类锁是用于类的静态方法或者一个类的class对象上的。 Ag.class

        我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，
        所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。
 */

对象锁，  不同对象。

public class SynchrDemo {
    public static void main(String[] args) {

        Thread1 thread1 = new Thread1();
        Thread1 thread2 = new Thread1();

        thread1.start();
        thread2.start();

    }
}

class Ag{
    public void show(){
        // this 是当前对象的实例，由于新建两个对象，不是同一对象。所以这里是锁不住的。   代码快的方式，比修饰在方法上更细化控制。
        synchronized (this) {
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + " i=" + i);
            }
        }
    }

}

class Thread1 extends Thread{
    @Override
    public void run() {
        //这里是新建对象  主方法中new了两个thread，就是new了两个Ag对象
        Ag ag = new Ag();
        ag.show();

    }
}

关键字修饰方法

public class SynchrDemo {
    public static void main(String[] args) {

        Thread1 thread1 = new Thread1();
        Thread1 thread2 = new Thread1();

        thread1.start();
        thread2.start();

    }
}

class Ag{
    // 这次修饰的是方法，范围比代码块要大，意味着在这个区域内，锁生效的时候，都是在阻塞，其他线程的等待时间就会增加。
    // 这次实验的非同一对象，所以这里的锁是不起作用的。
    public synchronized void show(){
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + " i=" + i);
            }
    }

}

class Thread1 extends Thread{
    @Override
    public void run() {
        //这里是新建对象  主方法中new了两个thread，就是new了两个Ag对象
        Ag ag = new Ag();
        ag.show();

    }
}

二  对象锁  同一对象

package com.aaa.threaddemo;
/*
 * 一 Java中的关键字  synchronized  是啥？
 *         synchronized是Java提供的一个并发控制的关键字。
 *
 *         用法：同步方法 和 同步代码块。
 *              可以修饰方法 也可以  修饰代码块。
 *
 *         作用： 被synchronized修饰的代码块及方法，在同一时间，只能被单个线程访问。【保证线程安全】

    1 修饰方法和代码块有什么不同？
         二者的结果是一样的

         修饰方法时，作用域是整个方法，控制的范围大。

         synchronized 代码块 可控制具体的作用域，更精准控制提高效率。
         减少阻塞带来的时间问题。

    2 同步锁的给谁用的？
        同步锁基于对象，只要锁的来源一致，即可达到同步的作用。
        所以，但对象不一样，则不能达到同步效果。

    3 synchronized修饰方法，代码块，锁未释放，此时，其他线程调用同一对象的其他被synchronized修饰的方法，代码块，会如何？
        当线程 A 调用某对象的synchronized 方法 或者 synchronized 代码块时，若同步锁未释放，
        其他线程调用同一对象的其他 synchronized 方法 或者 synchronized 代码块时将被阻塞，直至线程 A 释放该对象的同步锁。（注意：重点是其他）

    4 调用非synchronized方法 ，代码快呢？
        当线程 A 调用某对象的synchronized 方法 或者 synchronized 代码块时，无论同步锁是否释放，
        其他线程调用同一对象的其他 非 synchronized 方法 或者 非 synchronized 代码块时可立即调用。

    5 全局锁如何实现？
        全局锁： 锁住整个 Class，而非某个对象或实例。1-4都是实例锁
        实现： 静态 synchronized 方法

        static 声明的方法为全局方法，与对象实例化无关，
        所以 static synchronized 方法为全局同步方法，与对象实例化无关。

    6 synchronized 具体 Class 的代码块？
        synchronized (Ag.class) 获得的同步锁是全局的，
        static synchronized 获得的同步锁也是全局的，同一个锁，所以达到同步效果。

    7 对象锁和【类锁】 全局锁的关系？
        对象锁是用于对象实例方法，或者一个对象实例上的   this
        类锁是用于类的静态方法或者一个类的class对象上的。 Ag.class

        我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，
        所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。

 *
 *
 */

/*
 *
 对象锁和【类锁】 全局锁的关系？
        对象锁是用于对象实例方法，或者一个对象实例上的   this
        类锁是用于类的静态方法或者一个类的class对象上的。 Ag.class

        我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，
        所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。
 */

public class SynchrDemo {
    public static void main(String[] args) {

        // 改造后，可以确保是同一对象  验证  synchronized  是否生效
        Ag ag = new Ag();

        Thread1 thread1 = new Thread1(ag);
        Thread1 thread2 = new Thread1(ag);

        thread1.start();
        thread2.start();

    }
}

class Ag{
    // 这次修饰的是方法，范围比代码块要大，意味着在这个区域内，锁生效的时候，都是在阻塞，其他线程的等待时间就会增加。
    // 这次实验的同一对象，所以这里的锁是起作用的。
    public synchronized void show(){
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + " i=" + i);
            }
    }

}

/*
 *   改造一些 对象的生成，确保在Thread1 中获得的是同一对象
 */
class Thread1 extends Thread{    

    private Ag mag;

    public  Thread1(Ag ag) {
        mag = ag;
    }

    @Override
    public void run() {
        mag.show();

    }
}

验证代码快的方式？

public class SynchrDemo {
    public static void main(String[] args) {

        // 改造后，可以确保是同一对象  验证  synchronized  是否生效
        Ag ag = new Ag();

        Thread1 thread1 = new Thread1(ag);
        Thread1 thread2 = new Thread1(ag);

        thread1.start();
        thread2.start();

    }
}

class Ag{
    // 这次修饰的是方法，范围比代码块要大，意味着在这个区域内，锁生效的时候，都是在阻塞，其他线程的等待时间就会增加。
    // 这次实验的同一对象，所以这里的锁是起作用的。
    public  void show(){
        synchronized (this) {
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + " i=" + i);
            }

            // this 就是当前的对象，我们现在获得就是同一对象
            System.out.println(this);
        }
    }

}

/*
 *   改造一些 对象的生成，确保在Thread1 中获得的是同一对象
 */
class Thread1 extends Thread{    

    private Ag mag;

    public  Thread1(Ag ag) {
        mag = ag;
    }

    @Override
    public void run() {
        mag.show();

    }
}

三   类锁？  非同一对象

/*
 *
 * 类锁，全局锁如何实现？
        全局锁： 锁住整个 Class，而非某个对象或实例

        实现：
        1    在静态方法上用 synchronized 关键字修饰
        2    在代码块上使用 类名.class

        static 声明的方法为全局方法，与对象实例化无关，
        所以 static synchronized 方法为全局同步方法，与对象实例化无关。
 */

public class SynchrDemo {
    public static void main(String[] args) {

        //非同一对象
        Thread2 thread1 = new Thread2();
        Thread2 thread2 = new Thread2();

        thread1.start();
        thread2.start();

    }
}

class Ag{
    public  void show(){
        // 使用 synchronized（）  方法，将锁控制在代码快上。
        synchronized (Ag.class) {
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + " i=" + i);
            }

            // this 就是当前的对象，我们现在获得就是非同一对象
            System.out.println(this);
        }
    }

}

class Thread2 extends Thread{

    @Override
    public void run() {
        Ag ag = new Ag();
        ag.show();

    }
}

测试   关键字修饰 static 方法

public class SynchrDemo {
    public static void main(String[] args) {

        //非同一对象
        Thread2 thread1 = new Thread2();
        Thread2 thread2 = new Thread2();

        thread1.start();
        thread2.start();

    }
}

class Ag{
    // 静态的方法  被synchronized 修饰后， 锁住的是 类。
    public static synchronized  void show(){
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + " i=" + i);
            }
    }

}

class Thread2 extends Thread{

    @Override
    public void run() {
        Ag ag = new Ag();
        ag.show();

    }
}