synchronized用法

最新推荐文章于 2023-02-26 16:18:01 发布

原创最新推荐文章于 2023-02-26 16:18:01 发布 · 110 阅读

0 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

9 篇文章

订阅专栏

本文深入解析Java中的同步机制，包括互斥锁、内置锁、类锁的概念及其应用场景。通过实例演示了synchronized关键字如何用于代码块、实例方法及静态方法，展示了不同加锁方式下线程的执行行为。并对比了代码块与方法级别的锁的区别，强调了合理使用锁对提高程序执行效率的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

互斥锁：当一线程进入synchronized修饰的代码块或者方法，其它线程等待，知道锁被释放；
内置锁：对象锁，每个java对象都能当成一个锁使用，这个锁就是内置锁，内置锁也是互斥锁；
类锁：用于静态方法。类锁实际上也是对象锁，它作用于class对象，每个类只有一个class对象；
synchronized可以用于修饰代码块，实例方法，静态方法，不能用于修饰类；

修饰代码块和实例方法

public class Dog {
    //修饰代码块
    public void test1(){
        synchronized (this) {
            int i = 0 ;
            while( i < 5 ){
                System.out.println(Thread.currentThread().getName() +  "-执行到第"+ i + "步");
                i ++ ;
            }
        }
    }
    
    //修饰方法
    public synchronized void test2(){
        int i = 0 ;
        while( i < 5 ){
            System.out.println(Thread.currentThread().getName() +  "-执行到第"+ i + "步");
            i ++ ;
        }
    }
    
    public static void main(String[] args) {
        final Dog dog = new Dog();
        Thread read1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                dog.test1();
            }
        });
        
        //final Dog dog1 = new Dog();
        Thread read2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                dog.test2();
                                //dog1.test2();
            }
        });
        read1.start();
        read2.start();
    }
}
/*
1.代码块和实例方法同时加锁执行
Thread-0-执行到第0步
Thread-0-执行到第1步
Thread-0-执行到第2步
Thread-0-执行到第3步
Thread-0-执行到第4步
Thread-1-执行到第0步
Thread-1-执行到第1步
Thread-1-执行到第2步
Thread-1-执行到第3步
Thread-1-执行到第4步
2.代码块加锁，实例方法不加锁（或者实例方法加锁，代码块不加锁）
Thread-0-执行到第0步
Thread-0-执行到第1步
Thread-1-执行到第0步
Thread-1-执行到第1步
Thread-1-执行到第2步
Thread-1-执行到第3步
Thread-1-执行到第4步
Thread-0-执行到第2步
Thread-0-执行到第3步
Thread-0-执行到第4步
3.代码块和实例方法同时加锁,但是线程1用dog对象调用，线程2用dog1调用，执行。
Thread-0-执行到第0步
Thread-0-执行到第1步
Thread-0-执行到第2步
Thread-0-执行到第3步
Thread-0-执行到第4步
Thread-1-执行到第0步
Thread-1-执行到第1步
Thread-1-执行到第2步
Thread-1-执行到第3步
Thread-1-执行到第4步
*/

的执行结果1，test1中的代码块加锁，test2实例方法加锁，这里都是使用的同一个对象锁（或者内置锁），那么它将导致test1，test2同步，其中一个线程执行完毕后才会执行另一个线程。
的执行结果2，test1代码块加锁，test2方法不加锁，两个线程交替执行循环语句，这说明加锁的方法或代码块和不加锁的实例方法是不相干扰的，反之也一样。
可以简单理解为synchronized修饰意味着加锁，具体表现为，synchronized修饰的代码块或者实例方法需要获取锁才能执行，否者阻塞等待。
的执行结果3，执行结果和1的一样，两个实例不同，那么两个线程获取锁不为同一个对象锁，互不干扰。

修饰静态方法

public class Cat {
    //修饰代码块
    public static void test(){
        synchronized(Cat.class){
            int i = 0;
            do {
                System.out.println(Thread.currentThread().getName() + "当前运行:" + i);
                i ++;
            } while (i < 5);
        }
    }
    
    public static synchronized void test1(){
        int i = 0;
        do {
            System.out.println(Thread.currentThread().getName() + "当前运行:" + i);
            i ++;
        } while (i < 5);
    }
    
    public static void main(String[] args) {
        Thread read = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                Cat.test();
            }
        });
        
        Thread read1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                Cat.test1();
            }
        });
        read.start();
        read1.start();
    }
}

同修饰代码块和实例方法 的操作方式，三种测试结果并无不同。区别在于，修饰代码块和实例方法的synchronized(Object)中的Object是可选择的，不通实例的同步方法调用test1方法互不干扰，而此处，synchronized(Cat.class)只能给Cat.class加锁，同时给两个静态方法或者方法中的代码块加锁，多线程调用必须阻塞排队执行。

修饰代码块和修饰方法的区别

public class Difference {
    //修饰代码块
    public synchronized void  test1(){
        int i = 0 ;
        while( i < 5 ){
            System.out.println(Thread.currentThread().getName() +  "-执行到第"+ i + "步");
            i ++ ;
        }
        
        System.out.println("同步代码结束");
        int j = 0 ;
        while( j < 5 ){
            System.out.println("同步之后的逻辑"+ j );
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            j ++ ;
        }
    }
    
    //修饰方法
    public synchronized void test2(){
        int i = 0 ;
        while( i < 5 ){
            System.out.println(Thread.currentThread().getName() +  "-执行到第"+ i + "步");
            i ++ ;
        }
    }
    
    public static void main(String[] args) {
        final Difference dif = new Difference();
        Thread read1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                dif.test1();
            }
        });
        
        Thread read2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                dif.test2();
            }
        });
        read1.start();
        read2.start();
    }
}
结果：
Thread-0-执行到第0步
Thread-0-执行到第1步
Thread-0-执行到第2步
Thread-0-执行到第3步
Thread-0-执行到第4步
同步代码结束
同步之后的逻辑0
同步之后的逻辑1
同步之后的逻辑2
同步之后的逻辑3
同步之后的逻辑4
Thread-1-执行到第0步
Thread-1-执行到第1步
Thread-1-执行到第2步
Thread-1-执行到第3步
Thread-1-执行到第4步

test1()，test2()是两个同步方法，但是test1()中有一部分不需要同步并且耗时的代码，当test1()方法用synchronized修饰，两个同步方法都是获取的同一个对象锁（this），所以不需要加锁的代码也会阻塞执行。
现在将test1()修改如下：

    //修饰代码块
    public  void  test1(){
        synchronized(this){
            int i = 0 ;
            while( i < 5 ){
                System.out.println(Thread.currentThread().getName() +  "-执行到第"+ i + "步");
                i ++ ;
            }
        }
        
        System.out.println("同步代码结束");
        int j = 0 ;
        while( j < 5 ){
            System.out.println("同步之后的逻辑"+ j );
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            j ++ ;
        }
    }
结果：
Thread-0-执行到第0步
Thread-0-执行到第1步
Thread-0-执行到第2步
Thread-0-执行到第3步
Thread-0-执行到第4步
同步代码结束
同步之后的逻辑0
Thread-1-执行到第0步
Thread-1-执行到第1步
Thread-1-执行到第2步
Thread-1-执行到第3步
Thread-1-执行到第4步
同步之后的逻辑1
同步之后的逻辑2
同步之后的逻辑3
同步之后的逻辑4

可以看到不需要同步的逻辑不被对象锁影响，简而言之，尽量使用代码块并且尽可能在代码块中少放代码有助于提升逻辑执行效率。
最后提一下，同时启动两个线程，一个调用同步实例方法，一个调用同步静态方法，两者不相互影响（因为两者的对象锁不一样）。

参考