深入理解synchronized

刺骨的言语ヽ痛彻心扉 2021-09-29 11:44 400阅读 0赞

> 1.synchronize关键字用于加锁，用来解决多线程中，多个线程对同一资源访问所造成的数据不安全的问题  
> 2.使用synchronized修饰，相当于加了一把锁，对于synchronized锁定的资源，同一时间，只能有一个线程访问，保证了原子性。

线程不安全的代码示例：

class Ticket implements Runnable { 
        private int num;    //票的数量
    
        Ticket(int num){ 
            this.num = num;
        }
    
        //售票
        public void sale() { 
            if(num>0) { 
                num--;
                System.out.println(Thread.currentThread().getName()+"-------"+remain());
            }
        }
    
        //获取剩余票数
        public int remain() { 
            return num;
        }
    
        public void run(){ 
            while(true) { 
                sale();
            }
        }
    }
    
    public class ConcurrentDemo { 
        public static void main(String[] args) { 
            Ticket t = new Ticket(100);
            //创建多个线程对象
            Thread t1 = new Thread(t);
            Thread t2 = new Thread(t);
            Thread t3 = new Thread(t);
            Thread t4 = new Thread(t);
    
            //开启多个线程使其执行任务
            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }
    }

结果：  
![在这里插入图片描述][20190711191833244.png]

但是当synchronized关键字，也就是加锁，则可以避免这种问题

--------------------

### synchronized的使用 ###

**1. 修饰方法**

public synchronized void sale() {   
            if(num>0) { 
                num--;
             
                System.out.println(Thread.currentThread().getName()+"===sale2==========="+remain());
            }
        }

*  在方法前面加上synchronized关键字表示作用于该方法
 *  需要注意方法有两种，一种静态方法，一种非静态方法
 *  两者区别在于，当修饰静态时候，大家都调用的是同一个。当修饰非静态方法时候，调用的是每个对象自己的那个方法，因为非静态域或方法是每个对象各自都有一份的，静态方法是所有对象公有的。

**2. 修饰对象**

*修饰当前对象*

public void sale() { 
            synchronized(this) {   
                if(num>0) { 
                    num--;
                    
                    System.out.println(Thread.currentThread().getName()+"===sale1==="+remain());
                }
            }
        }

*修饰类对象*

public void sale() { 
            synchronized(Ticket.class) {   
                if(num>0) { 
                    num--;
                    
                    System.out.println(Thread.currentThread().getName()+"===sale1==="+remain());
                }
            }
        }

*  synchronized 函数的本质其实是使用了 () 里面的对象 作为这个同步函数的锁标识，this 代表的是当前对象的引用，Ticket.class代表是类对象。
 *  如果同步函数是静态的，即使用了 static 修饰，则此时 this 还没出现，它使用的锁是 “类名.class” 这个字节码文件对象，对于 java 来说，这也是一个对象，而且一个类中一定有这个对象。
 *  使用相同的锁之间会互斥，但不同锁之间则没有任何影响。因此，要保证任务同步 (原子性)，这些任务所关联的锁必须相同。也因此，如果有多个同步任务 (各自保证自己的同步性)，就一定不能都使用同步函数。

--------------------

### 锁的种类 ###

**1. 类锁**

类锁，是用来锁类的，我们知道一个类的所有对象共享一个 class 对象，共享一组静态方法，类锁的作用就是使持有者可以同步地调用静态方法。**当 synchronized 指定修饰静态方法或者 class 对象的时候**，拿到的就是类锁，类锁是所有对象共同争抢一把。

**2. 对象锁**

对象锁，是用来对象的，虚拟机为每个的非静态方法和非静态域都分配了自己的空间，不像静态方法和静态域，是所有对象共用一组。  
所以 synchronized 修饰非静态方法或者 this 的时候拿到的就是对象锁，**对象锁是每个对象各有一把**的，即同一个类如果有两个对象。那么这两个对象是并行执行的（线程不安全），即使方法加了对象锁。

--------------------

[20190711191833244.png]: /images/20210920/786a118d777b493daeefb36c4a89a23b.png