【java基础--Synchronized与lock】

港控/mmm° 2024-03-16 10:39 32阅读 0赞

## 对比 ##

lock是显式锁，synchronized是隐式锁，出了作用域自动释放
    lock只有代码块锁，synchronized有代码块锁和方法锁
    使用lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有较好的扩展性（提供更多子类）
    优先使用顺序：
        lock > 同步代码块 > 同步方法

## synchronized ##

*  ***修饰实例方法***: 作用于当前对象实例加锁，进入同步代码前要获得 **当前对象实例的锁**

synchronized void method() {
        
      //业务代码
    }

public class TestSynchronized implements Runnable{
        
        public static void main(String[] args) {
        
            TestSynchronized testSynchronized = new TestSynchronized();
            new Thread(testSynchronized,"a").start();
            new Thread(testSynchronized,"b").start();
            new Thread(testSynchronized,"c").start();
        }
        private int ticket = 10;
        boolean flag = true;
        @Override
        public void run() {
        
            while (flag){
        
                buy();
            }
        }
        private synchronized void buy(){
        
            if (ticket<=0){
        
                flag=false;
                return;
            }
            try {
        
                Thread.sleep(200);
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+" get "+ticket--);
        }
    }

![7487cb4c98584a2b80005f7c448bfee9.png][]

*  ***修饰静态方法***: 也就是给当前类加锁，会作用于类的**所有对象实例** ，进入同步代码前要获得 当前 class 的锁。因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管 new 了多少个对象，只有一份）。所以，如果一个线程 A 调用一个实例对象的非静态 synchronized 方法，而线程 B 需要调用这个实例对象所属类的静态 synchronized 方法，是**允许**的，**不会发生互斥**现象，因为*访问静态synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁。*

synchronized void static method() {
        
      //业务代码
    }

*  ***修饰代码块***: 指定加锁对象，对给定对象/类加锁。*synchronized(this|object)* 表示进入同步代码库前要获得给定对象的锁。*synchronized(类.class)* 表示**进入同步代码前**要获得 当前 class 的锁

synchronized(this) {
        
      //业务代码
    }

## lock ##

*  不加锁

public class TestLock {
        
        public static void main(String[] args) {
        
            TestLock2 testLock2 = new TestLock2();
            new Thread(testLock2).start();
            new Thread(testLock2).start();
            new Thread(testLock2).start();
        }
    }
    
    class TestLock2 implements Runnable{
        
        int ticket = 10;
        @Override
        public void run() {
        
            while (true){
        
                if (ticket>0){
        
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                    System.out.println(ticket--);
                }else{
        
                    break;
                }
            }
        }
    }

![764c7659fb4b4d0182bf3c4e83ccdad3.jpeg_pic_center][]

*  加锁

class A{
        
        private final ReentrantLock lock = new ReentrantLock();
        public void m(){
        
            lock.lock();
            try {
        
                //保证线程安全的代码
            }finally {
        
                lock.unlock();
                //如果同步代码有异常，要将unloc（）写入finally语句块
            }
        }
    }

import java.util.concurrent.locks.ReentrantLock;
    
    public class TestLock {
        
        public static void main(String[] args) {
        
            TestLock2 testLock2 = new TestLock2();
            new Thread(testLock2).start();
            new Thread(testLock2).start();
            new Thread(testLock2).start();
        }
    }
    
    class TestLock2 implements Runnable{
        
        int ticket = 10;
        //定义lock锁
        private final ReentrantLock lock = new ReentrantLock();
        @Override
        public void run() {
        
            while (true){
        
                try {
        
                    lock.lock();//加锁
                    if (ticket>0){
        
                        try {
        
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                        System.out.println(ticket--);
                    }else{
        
                        break;
                    }
                }finally {
        
                    //解锁
                    lock.unlock();
                }
            }
        }
    }

![在这里插入图片描述][4d79f5e912c14d7997a7a836c54ec4e5.png]

[7487cb4c98584a2b80005f7c448bfee9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/45b869f0d4644c70ba4cbe2c34e9771a.png
[764c7659fb4b4d0182bf3c4e83ccdad3.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/05e6227b09944e15a23c52bd806a83e7.png
[4d79f5e912c14d7997a7a836c54ec4e5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/bc3bd3e2b7ac4a71abafa4cd406a9070.png