Java多线程同步互斥执行某个方法或某段代码

Dear 丶 2022-04-13 10:23 125阅读 0赞

1. 使用synchronized关键字  
(1) 同步方法  
修饰对象实例方法  
e.g.

class A{
       
    private final byte[] INSTANCE_LOCK=new byte[0];
    synchronized void instanceMethod(){
       
    }
    }
    A a1 = new A();
    A a2 = new A();
    A a3=new A();

当多个线程调用a的方法instanceMethod时，同一时刻只有一个线程能执行  
线程1执行a1. instanceMethod()  
线程2执行a1. instanceMethod()  
线程3执行a2. instanceMethod()  
线程4执行a2. instanceMethod()  
线程5执行a3. instanceMethod()  
线程6执行a3. instanceMethod()  
同一时刻线程1、2只有一个线程能执行a1. instanceMethod()  
同一时刻线程3、4只有一个线程能执行a2. instanceMethod()  
同一时刻线程5、6只有一个线程能执行a3. instanceMethod()  
线程1(或2 )、3(或4)、5(或6)并不同步互斥

synchronized void instanceMethod(){
       
    }
    //等价于
    void instanceMethod(){
       
    synchronized(this){
       
    }
    }

对象锁为当前的对象实例，如a1,a2,a3等  
也可等价于

void instanceMethod(){
       
    sysnchronized(INSTANCE_LOCK){
       
    }
    }
    
    //修饰类方法(静态方法)
    //e.g.
    class B{
       
    private static final byte[] CLASS_LOCK=new byte[0];
    synchronized static void classMethod(){
       
    }
    }

当多个线程调用B的静态方法classMethod()，同一时刻只有一个线程能执行  
例如  
B b1 = new B();  
B b2 = new B();  
B b3 = new B();  
线程1执行b1. classMethod()或B.classMehoth()  
线程2执行b2.classMethod()或B.classMehoth()  
线程3执行b3.classMehtoed()或B.classMehoth()  
同一时刻线程1、2、3只有一个线程能执行B.classMehoth()

synchronized static void classMethod(){
       
    }
    //等价于
    void classMethod(){
       
    synchronized (B.class)
    }
    }

对象锁为当前的对象所属的类  
也等价于

void classMethon(){
       
    Synchronized(CLASS_LOCK){
       
    }
    }

注：获取对象锁之后便可以进入方法或代码块，当方法或代码执行完对象锁自动释放  
(2) 同步代码块

Object lock;
    synchronize(lock){
       
    //……
    }

拥有对象锁lock之后便可以进入代码块，代码执行完对象锁lock自动释放  
  
2. wait()、notify()  
Object lock;  
1.lock.wait() 释放对象锁，并让当前线程(执行lock.wait()的线程)等待直到另一个线程调用lock.notify()  
2.lock.notify() 唤醒其他线程(执行lock.wait()的线程)  
  
使用wait()和notify()时，当前线程应该拥有对象锁  
(the owner of this object's monitor)

synchronized (lock){
       
    // 拥有对象锁进入代码块
    // do a 
    lock.wait(); // 手动释放对象锁(让其他线程可以拥有对象锁),等待直到其他线程通知
    // 收到通知后do b
    }
    
    synchronized(lock){
       
    //拥有对象锁do c
    Lock.notify();// 通知等待线程执行(The awakenedthread will not be able to proceed until the current thread relinquishes thelock on this object)
    // 继续do d
    // 自动释放对象锁(唤醒的线程可以执行了)
    }