java synchronized 同步

1.修饰 非静态方法 锁对象 public synchronized void func(){}

2.修饰 静态方法 锁类 public synchronized static void func(){}

3.修饰 代码块 可以锁变量， 对象，类

锁变量 public void func(Integer num){ synchronized(num){}}

锁对象 public void func(){synchronized(this){}}

锁类  public void func(){synchronzed(Data.class){}}

package com.lt.test;

import java.util.concurrent.TimeUnit;

public class testUnit {

    public static void main(String[] args) {

        // 关键是看锁的是什么，如果是同一个资源，那么就需要等待，不是同一个资源就不需要等待
        //测试 对象锁  修饰的是非静态方法
        Data data = new Data();
        new Thread(()->{data.fun1();},"name1").start();
        new Thread(()->{data.fun2();},"name2").start();

        //测试 类锁 修饰的是静态方法
        new Thread(()->{ Data2.fun1();},"name1").start();
        new Thread(()->{ Data2.fun2();},"name2").start();

        //测试 代码块锁 可以锁对象，可以锁类，可以锁变量 修饰的代码块
        //锁对象 只创建一个对象，同步生效
        Data3 data3 = new Data3();
        for (int i = 0; i <3; i++) {
            new Thread(()->{
                data3.fun1();
            },"name"+i).start();
        }

        //锁对象 创建多个对象，锁失效
        for (int i = 0; i <3; i++) {
            Data3 data31 = new Data3();
            new Thread(()->{
                data31.fun1();
            },"name"+i).start();
        }

        //锁类  创建一个或者多个对象，锁都生效
        Data3 cdata3 = new Data3();
        for (int i = 0; i <3; i++) {
            Data3 data31 = new Data3();
            new Thread(()->{
                cdata3.fun2();
            },"name"+i).start();
        }
        for (int i = 0; i <3; i++) {
            Data3 data31 = new Data3();
            new Thread(()->{
                data31.fun2();
            },"name"+i).start();
        }
        //锁方法的变量num 变量在内存中只有一个时，锁是生效，方法Integer 变量的常量池范围是 -128-127，在这个范围外，方法调用的时候num 都会被重新创建，这时锁失效。
        for (int i = 0; i < 3; i++) {
            Data3 data33 = new Data3();
            new Thread(()->{
                data33.fun3();
            },"name"+i).start();
        }
        Data3 fdata33 = new Data3();
        for (int i = 0; i < 3; i++) {

            new Thread(()->{
                fdata33.fun3();
            },"name"+i).start();
        }

        //锁类非静态变量  变量在内存中只有一个时，锁是生效，方法Integer 变量的常量池范围是 -128-127，在这个范围外，方法调用的时候num 都会被重新创建，这时锁失效。
        for (int i = 0; i < 3; i++) {
            Data3 data33 = new Data3();
            new Thread(()->{
                data33.fun4();
            },"name"+i).start();
        }
        Data3 cdata33 = new Data3();
        for (int i = 0; i < 3; i++) {

            new Thread(()->{
                cdata33.fun4();
            },"name"+i).start();
        }

        //锁类静态变量  变量在内存中只有一个时，锁是生效，方法Integer 变量的常量池范围是 -128-127，在这个范围外，方法调用的时候num 都会被重新创建，这时锁失效。
        for (int i = 0; i < 3; i++) {
            Data3 data33 = new Data3();
            new Thread(()->{
                data33.fun5();
            },"name"+i).start();
        }
        Data3 data33 = new Data3();
        for (int i = 0; i < 3; i++) {

            new Thread(()->{
                data33.fun5();
            },"name"+i).start();
        }

        //被锁的变量必须初始化。也就是在内存中必须有。方法变量，非静态变量，静态变量的锁原理是一样


    }

    // 修饰非静态方法--锁的是同一个对象 资源
    static class Data{
        public synchronized void fun1(){
            try {
                TimeUnit.SECONDS.sleep(1);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("object1");
        }

        public synchronized  void fun2(){
            System.out.println("object2");
        }
    }

    // 修饰的是静态方法，锁的是类资源
    static  class Data2{
        public synchronized static void fun1() {
            try{
                TimeUnit.SECONDS.sleep(1);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("class1");
        }

        public synchronized static void fun2(){
            System.out.println("class2");
        }
    }

    static class Data3{
        // 锁对象
        public void fun1(){
            synchronized (this){
                System.out.println("object-start");
                try{
                    TimeUnit.SECONDS.sleep(1);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("object-end");
            }
        }
        //锁类
        public void fun2(){
            synchronized (Data3.class){
                System.out.println("class-start");
                try{
                    TimeUnit.SECONDS.sleep(1);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("class-end");
            }
        }


        //锁方法变量
        public void fun3(){
            Integer num = 1;
            synchronized (num){
                System.out.println("num-start");
                try{
                    TimeUnit.SECONDS.sleep(1);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("num-end");
            }
        }

        private Integer numObject=1;
        //锁非静态变量
        public void fun4(){
            synchronized (numObject){
                System.out.println("numObject-start");
                try{
                    TimeUnit.SECONDS.sleep(1);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("numObject-end");
            }
        }

        private static Integer numClass=127;
        //锁静态变量
        public void fun5(){
            synchronized (numClass){
                System.out.println("numClass-start");
                try{
                    TimeUnit.SECONDS.sleep(1);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("numClass-end");
            }
        }

    }
}