一定要会的synchronized关键字的用法

Posted 2022-12-03 Melody袁

synchronized(同步)关键字

修饰方法

1. 修饰普通方法，锁的是当前实例对象
2. 修饰静态方法，锁的是当前类的Class对象

修饰代码块，锁的是synchronized括号里的对象

public class SyncDemo1 
    //修饰普通方法
    public synchronized void method()

    
    //修饰静态方法
    public static synchronized void staticMethod()

    
    public void someMethod()
        //同步代码块
        //这里o是局部变量，外部不可能拿到，这种加锁是毫无意义的
        Object o = new Object();
        synchronized (o)
            //o这个引用不能为null
        
    

synchronized是如何实现加锁的？-----以同步代码块为例
java中的所有对象在jvm实现的时候，内部都包含一把锁，这把锁默认情况下是打开的。
对象可以调用getClass()方法从对象拿到该对象的“类对象”。

同步代码块的理解

synchronized(ref)//加锁
		一些语句;//加锁成功才能执行
//释放锁

普通同步方法的理解

	 //修饰普通方法
    public synchronized void method()

    
    //效果同上
    public void method1()
        synchronized (this)
            
        
    

静态同步方法的理解

	//修饰静态方法
    public static synchronized void staticMethod()

    
	//效果同上
    public  void staticMethod1()
        synchronized (SyncDemo1.class)

        
    

获取关于类的对象

1. 类名.class
2. 对象的引用.getClass

如果加锁失败，会怎么办？

（会触发线程调度隐含着必须执行操纵系统的代码才能完成这个工作，所有会有切换内核态的操作）

1. 加锁失败之后没有资格继续执行代码
2. 占据CPU没有意义
3. 会触发线程调度，加锁失败的线程，会被调度器从CPU上调度下来
4. 在锁打开之前，再分配CPU给该线程也没有意义
5. 线程状态要变化(不是RUNNABLE)
6. 线程状态编程BLOCKED(这个状态是专为sychronized加锁失败设置的专用状态)
7. 为了准备好当锁释放时能找到该线程，把它叫回， 把线程加到这把锁的阻塞队列中(blocking queue)

易错点

哪些情况下会导致两个线程之间产生互斥

public class SyncDemo2 
	//没加锁
    void method1() 
    
	//锁的时
    synchronized void method2() 
    

    static synchronized void method3() 
    

    void method4() 
        synchronized (this) 
        
    

    static void method5() 
        synchronized (SyncDemo2.class) 
        
    

    void method6() 
        synchronized (SyncDemo2.class) 
        
    

改造n++和n–操作，使得线程安全

只要保证同时加锁，加得是同一把锁，哪个对象都可以
锁得粒度会影响运行效率。

class Adder extends Thread
    Object o = new Object();
    Adder(Object o)
        this.o = o;
    


    @Override
    public void run() 
        synchronized (o) 
            for (long i = 0; i < 100_0000_0000L; i++) 

                ThreadDemo.n++;


            
        
    


class Suber extends Thread

    Object o = new Object();
    Suber(Object o)
        this.o = o;
    
    @Override
    public void run() 
        synchronized (o) 
            for (long i = 0; i < 100_0000_0000L; i++) 

                ThreadDemo.n--;

            
        
    

public class ThreadDemo 
    static int n = 0;

    public static void main(String[] args) throws InterruptedException 
        Object o = new Object();
        Thread a = new Adder(o);
        Thread b = new Suber(o);

        a.start();
        b.start();
        a.join();
        b.join();
        System.out.println(n);
    

当线程A在操作访问锁定的对象时候， 线程B如果要进入synchronized代码块执行的时候是必须等待锁释放的。这样实际上就是将原本并行执行的代码，变为串行执行了。

sychronized能保护什么，起到什么作用

1. 原子性
2. 内存可见性(sychronized加锁成功之后，必须做一次从主内存到工作内存得同步操作，保证线程看到的是最新的数据。释放锁之后，必须做一次从工作内存到主内存的刷新操作，保证所有最新的数据写回主内存。用了该关键字也不能保证一定会有同步操作)
3. 代码有序性
   加锁前的一些语句A
   加锁部分的一些语句B
   加锁后的一些语句C

创建一个线程安全的ArrayList

单线程下不建议使用Vector，因为Vector无脑给所有方法都加锁了，单线程下会有很多加锁和释放锁的操作来耗费时间。

public class ArrayList 
    private int size;
    private final long[]array = new long[100];
    public synchronized void add(long e)
        array[size++] = e;
    

    public synchronized int size()
        return size;
    

    public synchronized long get(int index)
        if (index > 0 || index >= size)
            throw new ArrayIndexOutOfBoundsException();
        
        return array[index];