Java 多线程同步-同步代码块&&同步方法

拼搏现实的明天。 2022-11-05 00:49 190阅读 0赞

我们回忆一下之前的火车票案例：

package com.veeja.thread;
    
    /** * @Author veeja * 2021/3/2 11:35 */
    public class BuyTicketThreadExtendTest { 
        public static void main(String[] args) { 
            BuyTicketThreadExtend t1 = new BuyTicketThreadExtend("one");
            BuyTicketThreadExtend t2 = new BuyTicketThreadExtend("two");
            t1.start();
            t2.start();
    
        }
    }
    
    class BuyTicketThreadExtend extends Thread { 
    
        /** * 总票数，为了使多个实例抢的都是这10张票，所以用static修饰 */
        static int ticketNumber = 10;
    
        /** * 设置线程名字的方法 * * @param name */
        public BuyTicketThreadExtend(String name) { 
            setName(name);
        }
    
        /** * 覆写run方法 */
        @Override
        public void run() { 
            for (int i = 0; i < 100; i++) { 
                if (ticketNumber > 0) { 
                    System.out.println("我在" + getName() + "买到了，座号为：\t" + ticketNumber--);
                }
            }
        }
    }

如果多运行几次，总会出现一些问题，比如买了两张同样的车票，或者是买了第0张车票，甚至-1张。而且还会出现乱序的情况，车票不是一张一张卖的而是乱序售出。

例如：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]  
其实这就反应了在多并发的情况下，带来的线程安全问题。

## 1. 同步代码块 ##

线程安全问题其实就是由多个线程同时处理共享资源所导致的。要想解决线程安全问题，**必须得保证用于处理共享资源的代码在任何时刻只能有一个线程访问。**

Java中提供了同步机制。当多个线程使用同一个共享资源时，可以将处理共享资源的代码放置在一个代码块中，使用Synchronized关键字来修饰，被称作同步代码块，其语法格式为：

synchronized(lock){ 
    	操作共享资源代码块
    }

> 上面的代码中, lock是一个锁对象﹐它是同步代码块的关键。  
> 当线程执行同步代码块时,首先会检查锁对象的标志位。默认情况下标志位为1,此时线程会执行同步代码块，同时将锁对象的标志位置为0。  
> 当一个新的线程执行到这段同步代码块时，由于锁对象的标志位为0，新线程会发生阻塞,等待当前线程执行完同步代码块后,锁对象的标志位被置为1,新线程才能进入同步代码块执行其中的代码。  
> 循环往复,直到共享资源被处理完为止。

例如上面的，就需要改为：

Object lock = new Object();
    
    synchronized (lock) { 
        if (ticketNumber > 0) { 
            System.out.println("我在" + getName() + "买到了，座号为：\t" + ticketNumber--);
        }
    }

这里要注意的是，我们的锁必须是同一把锁，如果创建了多个线程，各自都有各自的锁，那么就起不到作用了。

一般我们用本类的字节码作为锁，这样就保证了所有实例使用的是一把锁。

class BuyTicketThreadExtend extends Thread { 
       ...
                synchronized (BuyTicketThreadExtend.class) { 
    				...
    			}
    }

> 注意:  
> 同步代码块中的锁对象可以是任意类型的对象,但多个线程共享的锁对象必须是唯一的。“任意”说的是共享锁对象的类型。所以,锁对象的创建代码不能放到run()方法中,否则每个线程运行到run()方法都会创建一个新对象,这样每个线程都会有一个不同的锁,每个锁都有自己的标志位。线程之间便不能产生同步的效果。  
>   
>   
> 比如在实现Runnable接口的时候，我们可以用this来作为锁，this就是当前对象，因为线程类共用了一个对象，所以可以使用this作为锁：
> 
>     public class BuyTicketThreadImplementsTest { 
>         public static void main(String[] args) { 
>             BuyTicketThreadImplements tti = new BuyTicketThreadImplements();
>             Thread t1 = new Thread(tti, "窗口1");
>             Thread t2 = new Thread(tti, "窗口2");
>             t1.start();
>             t2.start();
>     
>         } }
>     
>     class BuyTicketThreadImplements implements Runnable { 
>         
>         int ticketNumber = 10;
>     
>         @Override
>         public void run() { 
>             for (int i = 0; i < 100; i++) { 
>                 synchronized (this) { 
>                     if (ticketNumber > 0) { 
>                         System.out.println("我在" + Thread.currentThread().getName() + "买到了票，座号为" + ticketNumber--);
>                     }
>                 }
>             }
>         } 
>     }
> 
> 但是我们在使用继承Thread的方式的时候，因为我们创建了不同的对象，所以再使用this就不是同一把锁了，就还会导致多线程安全问题。所以我们一般使用线程类的`.class`作为锁，
> 
>     public class BuyTicketThreadExtendTest { 
>         public static void main(String[] args) { 
>             BuyTicketThreadExtend t1 = new BuyTicketThreadExtend("one");
>             BuyTicketThreadExtend t2 = new BuyTicketThreadExtend("two");
>             t1.start();
>             t2.start();
>     
>         } }
>     
>     class BuyTicketThreadExtend extends Thread { 
>         static int ticketNumber = 10;
>     
>         public BuyTicketThreadExtend(String name) { 
>             setName(name);
>         }
>     
>         @Override
>         public void run() { 
>             for (int i = 0; i < 100; i++) { 
>                 synchronized (BuyTicketThreadExtend.class) { 
>                     if (ticketNumber > 0) { 
>                         System.out.println("我在" + getName() + "买到了，座号为：\t" + ticketNumber--);
>                     }
>                 }
>             }
>         } }

***接下来这段话是从笔记里面看到的，说的我一脸懵，似懂非懂，先放在这里吧：***

> **总结1：认识同步监视器（锁子）**`synchronized(同步监视器){ }`  
> 1)必须是引用数据类型，不能是基本数据类型  
> 2)也可以创建一个专门的同步监视器，没有任何业务含义  
> 3)一般使用共享资源做同步监视器即可  
> 4)在同步代码块中不能改变同步监视器对象的引用  
> 5)尽量不要String和包装类Integer做同步监视器  
> 6)建议使用final修饰同步监视器  
> **总结2：同步代码块的执行过程**  
> 1)第一个线程来到同步代码块，发现同步监视器open状态，需要close,然后执行其中的代码  
> 2)第一个线程执行过程中，发生了线程切换（阻塞 就绪），第一个线程失去了cpu，但是没有开锁open  
> 3)第二个线程获取了cpu，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态  
> 4)第一个线程再次获取CPU,接着执行后续的代码；同步代码块执行完毕，释放锁open  
> 5)第二个线程也再次获取cpu，来到了同步代码块，发现同步监视器open状态，拿到锁并且上锁，由阻塞状态进入就绪状态，再进入运行状态，重复第一个线程的处理过程（加锁）  
> 强调：同步代码块中能发生CPU的切换吗？能！！！ 但是后续的被执行的线程也无法执行同步代码块（因为锁仍旧close）  
> **总结3：其他**  
> 1)多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块  
> 2)多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块

## 2. 同步方法 ##

我们知道，刚才可能出现问题的代码就是抢火车票的那一段，

if (ticketNumber > 0) { 
        System.out.println("我在" + getName() + "买到了，座号为：\t" + ticketNumber--);
    }

我们现在把它抽取出来，形成一个方法，并且加上Synchronized关键字：

public synchronized void buyTicket() { 
        if (ticketNumber > 0) { 
            System.out.println("我在" + Thread.currentThread().getName() + "买到了票，座号为" + ticketNumber--);
        }
    }

其实这就形成了同步方法，同步方法的语法格式如下：

synchronized 返回值类型 方法名(参数1, ...){  }

被`synchronized`修饰的方法在某一时刻只允许一个线程访问，访问该方法的其他线程都会发生阻塞，直到当前线程访问完毕后，其他线程才有机会执行方法。

上面的程序我们可以改造一下：

public class BuyTicketThreadImplementsTest { 
        public static void main(String[] args) { 
            BuyTicketThreadImplements tti = new BuyTicketThreadImplements();
            Thread t1 = new Thread(tti, "窗口1");
            Thread t2 = new Thread(tti, "窗口2");
            t1.start();
            t2.start();
    
        }
    }
    
    class BuyTicketThreadImplements implements Runnable { 
    
        int ticketNumber = 10;
    
        @Override
        public void run() { 
            while (true) { 
                buyTicket();
                if (ticketNumber <= 0) { 
                    break;
                }
            }
        }
    
        public synchronized void buyTicket() { 
            if (ticketNumber > 0) { 
                try { 
                    Thread.sleep(10);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println("我在" + Thread.currentThread().getName() + "买到了票，座号为" + ticketNumber--);
            }
        }
    }

我们在上面的例子中，实现了Runnable接口的线程类通过实现同步方法是可以解决线程安全问题的，但是如果是继承Thread类的方式呢？

public class BuyTicketThreadExtendTest { 
        public static void main(String[] args) { 
            BuyTicketThreadExtend t1 = new BuyTicketThreadExtend("one");
            BuyTicketThreadExtend t2 = new BuyTicketThreadExtend("two");
            t1.start();
            t2.start();
    
        }
    }
    
    class BuyTicketThreadExtend extends Thread { 
    
        static int ticketNumber = 10;
    
        public BuyTicketThreadExtend(String name) { 
            setName(name);
        }
    
        @Override
        public void run() { 
            while (true) { 
                try { 
                    sleep(10);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                buyTicket();
                if (ticketNumber == 0) { 
                    break;
                }
            }
        }
    
        public synchronized void buyTicket() { 
            if (ticketNumber > 0) { 
                System.out.println("我在" + getName() + "买到了，座号为：\t" + ticketNumber--);
            }
        }
    }

我们运行几次，其实还是有问题的：

我在one买到了，座号为：	9
    我在two买到了，座号为：	10
    我在two买到了，座号为：	8
    我在one买到了，座号为：	7
    我在two买到了，座号为：	6
    我在one买到了，座号为：	5
    我在two买到了，座号为：	4
    我在one买到了，座号为：	3
    我在two买到了，座号为：	2
    我在one买到了，座号为：	1

卖出的次序是不对的。这是为什么呢？其实还是锁的问题，在继承Thread类的这种写法里面，我们的锁并不是同一把。这个时候，要在方法前加一个static修饰符，保证是同一把锁。

public static synchronized void buyTicket() { 
        if (ticketNumber > 0) { 
            System.out.println("我买到了，座号为：\t" + ticketNumber--);
        }
    }

但这样有些限制，我们在静态方法里面只能访问静态的方法和变量，所以其他非静态的变量和方法就无法访问了。

**总结：**  
首先，同步方法也有自己的锁，它的锁就是当前调用该方法的对象，也就是this指向的对象。  
这样做的好处是，同步方法被所有线程共享，方法所在的对象相对于所有线程来说也是唯一的，从而保证了锁的唯一性。当一个线程执行该方法时，其他的线程就不能进入该方法中，直到这个线程执行完该方法为止，从而达到了线程同步的效果。

但是，有时候我们的方法需要是静态方法，静态方法不需要创建对象就可以直接使用“类名.方法名”的方式调用。这个时候，我们都没有对象，那么同步方法的锁就不会是this，那是什么呢？  
Java中静态方法的锁是该类所在类的class对象，该对象可以直接使用`类名.class`的方式获取。

**关于同步方法**

1.  不要将run()定义为同步方法
2.  非静态同步方法的同步监视器是this  
    静态同步方法的同步监视器是 类名.class 字节码信息对象
3.  同步代码块的效率要高于同步方法  
    原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却是方法的内部
4.  同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块

同步代码块和同步方法解决了多线程的问题，使得在多个线程访问共享数据时变得安全，但是同时因为每次执行到同步代码块时每次都会判断锁的状态，非常的消耗资源，效率比较低。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]: /images/20221023/ef241d5339924851805ef83ad9e08669.png