并发编程3-synchronized

最新推荐文章于 2023-05-17 23:33:09 发布

bobshute

最新推荐文章于 2023-05-17 23:33:09 发布

阅读量143

点赞数

分类专栏： J2SE 总结文章标签：多线程并发编程

本文链接：https://blog.csdn.net/bobshute/article/details/86264301

版权

总结同时被 2 个专栏收录

88 篇文章 0 订阅

订阅专栏

J2SE

30 篇文章 0 订阅

订阅专栏

1.synchronized简介

1.1 使用场景

synchronized和内置锁（进入之后锁，出去之后解锁，实现原子操作，达到安全性）
- synchronized 放在普通方法上，获得的内置锁就是当前类的实例(对象)
- synchronized 修饰静态方法或class.Class中，内置锁是当前的Class字节码对象
- synchronized 修饰在同步代码快上,锁的粒度可以更细，并且充当锁的对象不一定是this，也可以是其它对象，所以使用起来更加灵活

1.2 特性

锁还是互斥的

内置锁（对象锁）
互斥锁
重入锁
synchronized和重入锁

public class T {
    public synchronized void  method1(){
        method2();
    }
    public synchronized void  method2(){
    }
}

method1和mehtod2方法上有synchronized,都是对是实例的锁.
进入method1的时候获取对象锁并锁.
然后调用method2,method2也要获取锁对象,但是锁对象被method1对象获取了.那method2能否执行,是否会死锁呢?
答案是不会,因为method1和method2都是一个线程,对同一个对象锁使用,可以重入,这就是重入锁的一种使用场景.

如果synchronized锁基础类型需要转换为对象类型,即synchronized(int)不行,需要synchronized(synchronized (Integer.valueOf(int)))
synchronized保证线程安全的原理（jvm层面）
monitorenter, monitorexit;
monitorenter 和 monitorexit详细意思是什么?
- monitorenter ：
  每个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：
  1)、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。
  2)、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.
  3).如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。
- monitorexit：
  　1)执行monitorexit的线程必须是objectref所对应的monitor的所有者。
  　2)指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。
  　3)Synchronized的语义底层是通过一个monitor的对象来完成，其实wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

举例:


public class GetSequence {

    private int value1;

    /**
     * 1.如果不加锁,则会出现重复或遗漏情况.
     */
    public  int getNext1() {
        return value1++;
    }


    /**
     * 关于synchronized
     * monitorenter-JVM层面[synchronized的时候]
     * 这里的synchronized(),传入的参数可以为object,所有内置所都可以当做参数
     *
     * synchronized_1_修饰普通方法:查看 ThreadRunnable2SynchronizedMethod
     * synchronized_2_修饰静态方法:查看ThreadRunnable3SynchronizedStaticMethod
     * synchronized_3_修饰this:查看ThreadRunnable4SynchronizedThis
     * synchronized_4_修饰value:查看ThreadRunnable5SynchronizedValue
     * synchronized_5_修饰value:查看ThreadRunnable6SynchronizedClass
     *
     * monitorexit-JVM层面[synchronized的时候]
     */


    /**
     *执行1:单线程情况下怎么都不会有重复
     */
    public static void singleThread(){
        GetSequence s = new GetSequence();
        for(int i =0;i<100;i++){
			System.out.println("singleThread->"+s.getNext1());
		}
    }

    /**
     * 执行2:默认多线程情况下会有重复
     */
    public static void multiThread1_Default(){
        ThreadRunnable1Default tr = new ThreadRunnable1Default();
        new Thread(tr).start();
        new Thread(tr).start();
        new Thread(tr).start();
    }



    /**
     * 执行3:Synchronized修饰method多线程情况下不会有重复
     */
    public static void multiThread_SynchronizedMethod(){
        ThreadRunnable2SynchronizedMethod tr = new ThreadRunnable2SynchronizedMethod();
        new Thread(tr).start();
        new Thread(tr).start();
        new Thread(tr).start();
    }


    /**
     * 执行4:Synchronized修饰static method多线程情况下不会有重复
     */
    public static void multiThread_SynchronizedStaticMethod(){
        ThreadRunnable3SynchronizedStaticMethod tr = new ThreadRunnable3SynchronizedStaticMethod();
        new Thread(tr).start();
        new Thread(tr).start();
        new Thread(tr).start();
    }

    /**
     * 执行5:Synchronized修饰this多线程情况下不会有重复
     */
    public static  void multiThread_SynchronizedThis(){
        ThreadRunnable4SynchronizedThis tr = new ThreadRunnable4SynchronizedThis();
        new Thread(tr).start();
        new Thread(tr).start();
        new Thread(tr).start();
    }


    /**
     * 执行7:Synchronized修饰Value多线程情况下不会有重复
     */
    public static  void multiThread_SynchronizedValue(){
        ThreadRunnable5SynchronizedValue tr = new ThreadRunnable5SynchronizedValue();
        new Thread(tr).start();
        new Thread(tr).start();
        new Thread(tr).start();
    }

    /**
     * 执行7:Synchronized修饰Class多线程情况下不会有重复
     */
    public static  void multiThread_SynchronizedClass(){
        ThreadRunnable6SynchronizedClass tr = new ThreadRunnable6SynchronizedClass();
        new Thread(tr).start();
        new Thread(tr).start();
        new Thread(tr).start();
    }


    public static void main(String[] args) {
        //执行1:如果单线程不会重复
        singleThread();

        //执行2:普通多线程情况下会有重复,会发现执行3个线程的最后3*100不等于300
        multiThread1_Default();

        //执行3:synchronized方法 多线程情况下不会有重复
        multiThread_SynchronizedMethod();

        //执行4:Synchronized修饰static method多线程情况下不会有重复
        multiThread_SynchronizedStaticMethod();

        //执行5:Synchronized修饰this多线程情况下不会有重复
        multiThread_SynchronizedThis();

        //执行6:Synchronized修饰value多线程情况下不会有重复
        multiThread_SynchronizedValue();

        //执行7:Synchronized修饰Class多线程情况下不会有重复
        multiThread_SynchronizedClass();
    }
}

public class ThreadRunnable1Default implements Runnable {

    private int value1;

    /**
     * 没有synchronized
     */
    public  int getNext1() {
        return value1++;
    }

    @Override
    public void run() {
        for(int i =0;i<100;i++){
            System.out.println("multiThread_Synchronized->"+Thread.currentThread().getName() + " " + getNext1());
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadRunnable2SynchronizedMethod implements Runnable {

    private int value2;

    /**
     * synchronized_1.synchronized 放在普通方法上，
     * 内置锁就是当前类的实例(对象)
     */
    public synchronized int getNext2() {
        return value2++;
    }

    @Override
    public void run() {
        for(int i =0;i<100;i++){
            System.out.println("multiThread_SynchronizedMethod->"+Thread.currentThread().getName() + " " + getNext2());
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadRunnable3SynchronizedStaticMethod implements Runnable {

    private static int value3;//在不加锁的情况下,即使是static也会造成重复或者遗漏

    /**
     * Synchronized_3.Synchronized修饰静态方法，
     * 内置锁是当前的Class字节码对象
     */
    public static synchronized int getNext() {
        return value3 ++;
    }


    @Override
    public void run() {
        for(int i =0;i<100;i++){
            System.out.println("multiThread_StaticMethod->"+Thread.currentThread().getName() + " " + getNext());
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadRunnable4SynchronizedThis implements Runnable {

    private int value2;

    /**
     * 如果锁this,等于在方法上加synchronized,等同于 public synchronized int method1() {}
     * 也就是锁对象,就是所有持有该对象的线程都可以进入,等同于2.1放在普通方法上，
     */
    public  int getNext2() {
        synchronized (this) {
            if (value2 >= 0) {
                return value2++;
            } else {
                return -1;
            }
        }
    }

    @Override
    public void run() {
        for(int i =0;i<100;i++){
            System.out.println("multiThread_ThreadRunnable4SynchronizedThis->"+Thread.currentThread().getName() + " " + getNext2());
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadRunnable5SynchronizedValue implements Runnable {

    private int value2;


    public  int getNext2() {
        //如果锁基本类型,需要转换为对象类型
        synchronized (Integer.valueOf(value2)){
            return value2++;
        }
    }

    @Override
    public void run() {
        for(int i =0;i<100;i++){
            System.out.println("multiThread_ThreadRunnable5SynchronizedValue->"+Thread.currentThread().getName() + " " + getNext2());
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadRunnable6SynchronizedClass implements Runnable {

    private int value2;

    public  int getNext2() {
        //锁字节码,字节码全局唯一,等同有2.2 .修饰静态方法，
        synchronized (GetSequence.class) {
            if (value2 >= 0) {
                return value2++;
            } else {
                return -1;
            }
        }
    }

    @Override
    public void run() {
        for(int i =0;i<100;i++){
            System.out.println("multiThread_ThreadRunnable6SynchronizedClass->"+Thread.currentThread().getName() + " " + getNext2());
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}