synchronized

2021-01-02  本文已影响0人  凉快先生

public class study02 {

public static void main(String[] args) {

        study02 study =new study02();

        Runnable runnable =new Runnable() {

            @Override

            public void run() {

                study.test();

            }

        };

        new Thread(runnable).start();

        new Thread(runnable).start();

    }

    private Objecto =new Object();

        public void test(){

            synchronized (o){

                System.out.println(Thread.currentThread().getName() +" 锁定o这个对象,当代码块获得这把锁的时候才能执行该代码块");

                try {

                    Thread.sleep(1000);

                }catch (InterruptedException e) {

                    e.printStackTrace();

                }

            System.out.println(Thread.currentThread().getName() +" test执行完毕");

        }

    }

    public synchronized void test2(){

        System.out.println("锁定的是this");

    }

    public synchronized static void test3(){

        System.out.println("static方法是没有this对象的,synchronized相当于synchronized(Study02.class)");

    }

}

synchronized不应该理解成锁定了某段代码或者某个方法,而是锁加在了一个对象上,当代码执行时,获得了该把锁才能运行。

在静态方法上加synvhronized是没有this的,相当于synvhronized(T.class)


synchronized是可重入锁

public class study03 {

    public static void main(String[] args) {

        study03 study =new study03();

            new Thread(()->{

                study.m1();

            }).start();

        }

    public synchronized void m1(){

        System.out.println(Thread.currentThread().getName()+" m1 start +++++++++++++++");

        m2();

        System.out.println(Thread.currentThread().getName()+" m1 end +++++++++++");

    }

    public synchronized void m2(){

        System.out.println(Thread.currentThread().getName()+" m2 start");

            try {

                Thread.sleep(1000);

            }catch (InterruptedException e) {

                e.printStackTrace();

           }

        System.out.println(Thread.currentThread().getName()+" m2 end");

    }

}

m1和m2都属于study对象,并且都加上了synchronized,程序会判断m1和m2是否在同一线程中,如果是,synchronized可重入。

为什么synchronized是可重入锁,模拟一个父子类概念,如果父类方法加上了synchronized,子类在重写父类方法的时候,调用super方法必需的可重入,否则会出问题(调用父类是同一把锁)。

可重入锁就是你拿到这把锁之后不停的加锁,加好几道锁,但锁定的是同一个对象,去掉就减一,就是这么个概念。


异常锁

当线程出现异常时,线程会自动释放锁,其他线程可获得该锁。


synchronized底层实现

synchronized锁升级概念:

1.偏向锁:第一个去访问某把锁的线程,比如sync(Object),来了之后先在Object上面markword记录这个线程(如果只有一个线程访问的时候实际上是没有给这个Object加锁的,在内部实现的时候,只是记录了这个线程的ID)

2.自旋锁:偏向锁如果有线程争用的话,会升级为自旋锁,它不会直接去cpu的就绪队列中去,而是用while的循环等着占用cpu,while多次之后仍获取不到锁才会再一次升级

3.重量级锁:自旋锁自旋10次后,升级为重量级锁,去操作系统那里申请资源

线程执行时间短,线程数少,用自旋锁等待;执行时间长,线程数多,用系统锁。

上一篇下一篇

猜你喜欢

热点阅读