java中的synchronized（同步代码块和同步方法的区别）

朴灿烈づ我的快乐病毒、 2022-05-28 06:10 284阅读 0赞

//下列两个方法有什么区别
    public synchronized void method1(){}
    
    public void method2(){
     synchronized  (obj){}
    }

synchronized用于解决同步问题，当有多条线程同时访问共享数据时，如果不进行同步，就会发生错误，java提供的解决方案是：只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行可以。解决这个问题。这里在用synchronized时会有两种方式，**一种是上面的同步方法，即用synchronized来修饰方法，另一种是提供的同步代码块。**

案例：

public class SynObj {
        public synchronized void methodA() {
            System.out.println("methodA.....");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public  void methodB() {
            synchronized(this) {
                System.out.pritntln("methodB.....");
            }
        }
    
        public void methodC() {
            String str = "sss";
            synchronized (str) {
                System.out.println("methodC.....");
            }
        }
    }

public class TestSyn { 
        public static void main(String[] args) {
            final SynObj obj = new SynObj();
    
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    obj.methodA();
                }
            });
            t1.start();
    
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    obj.methodB();
                }
            });
            t2.start();
    
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    obj.methodC();
                }
            });
            t3.start();
        }
    }

打印结果如下：

methodA.....
    methodC.....
    //methodB会隔一段时间才会打印出来
    methodB.....

这段代码的打印结果是，methodA…..methodC…..会很快打印出来，methodB…..会隔一段时间才打印出来，那么methodB为什么不能像methodC那样很快被调用呢？

在启动线程1调用方法A后，接着会让线程1休眠5秒钟，这时会调用方法C，**注意到方法C这里用synchronized进行加锁，这里锁的对象是str这个字符串对象**。但是方法B则不同，是用当前对象this进行加锁，注意到方法A直接在方法上加synchronized，这个加锁的对象是什么呢？显然，**这两个方法用的是一把锁**。

由这样的结果，我们就知道这样同步方法是用什么加锁的了，**由于线程1在休眠，这时锁还没释放，导致线程2只有在5秒之后才能调用方法B，由此，可知两种加锁机制用的是同一个锁对象，即当前对象。**  
另外，同步方法直接在方法上加synchronized实现加锁，同步代码块则在方法内部加锁，很明显，同步方法锁的范围比较大，而同步代码块范围要小点，一般同步的范围越大，性能就越差，一般需要加锁进行同步的时候，肯定是范围越小越好，这样性能更好。

总结：

**同步就是：一个对象同一时间只能为一个同步代码块服务**

**同步代码块需要传递的对象（锁对象）：就是锁住这个对象，表示这个对象正在为我服务，其他人不能用（非synchronized代码块、方法除外）**。

**同步方法：就是同步代码块，同步锁对象是this**

**同步静态方法：就是同步代码块，同步锁对象是类的class对象**（Demo类里的静态方法锁对象就是Demo.class）

OK了，这就是同步原理。再说简单点（**当一个对象被锁住之后，在该代码块之外去使用此对象的方法，只要遇到同步代码块，就会进入等待状态**）

那什么是死锁？死锁必须是多个线程对象才能够产生的。  
案例：

public class Demo {
        public static Demo a = new Demo();
        public static Demo b = new Demo();
        public void fun1(){
            synchronized(a) {
                System.out.println("fun1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {}
                b.fun2();
            }
        }
        public void fun2(){
            synchronized(b) {
                System.out.println("fun2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {}
                a.fun1();
            }
        }
    }
    
    死锁例子

fun1方法中，锁住了a对象，使用b对象。  
fun2方法中，锁住了b对象，使用a对象。  
这就是互相等待。  
你如果使用两个线程去调用这两个方法，就会死锁。