Java同步加锁机制synchrnized

痛定思痛。 2021-09-15 05:00 353阅读 0赞

（一）同步当前实例A 方法 的锁：

eg：当一个线程进入到A对象的一个synchrnized（）方法后，其他线程可以进入此对象的其他方法吗？

Service mService = new Service();
    Thread sleepThread = new Thread(new SleepThread(mService));
    Thread waitThread = new Thread(new WaitThread(mService));
    
    sleepThread.start();
    waitThread.start();

①：其他方法都加  加了synchrnized关键字\--->不能进入。，没加-->则能

代码：

public void mSleep() {
        synchronized (this) {
            try {
                System.out.println("Sleep当前时间：" + System.currentTimeMillis()/1000+" S");
                Thread.sleep(3000);
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void mWait() {
        synchronized (this){
            System.out.println("Wait等待时间：" + System.currentTimeMillis() / 1000 + " S");
        }
    }

结果：【加了synchrnized】

![70][]

注解掉（没有）synchrnized：

![70 1][]

②：其他方法都加了 synchrnized关键字，内部调用了wait，-->也不能进入

代码：

public void mSleep() {
        synchronized (this) {
            try {
                System.out.println("Sleep当前时间：" + System.currentTimeMillis()/1000+" S");
                Thread.sleep(3000);
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void mWait() {
        synchronized (this){
            try {
                System.out.println("Wait等待时间：" + System.currentTimeMillis() / 1000 + " S");
                this.wait(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

结果：

![70 2][]

③：当前方法内部调用了 wait（），--->则可以进入其他synchrnized方法。

代码：

public void mSleep() {
        synchronized (this) {
            try {
                System.out.println("Sleep当前时间：" + System.currentTimeMillis()/1000+" S");
                Thread.sleep(3000);
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void mWait() {
        synchronized (this){
            try {
                System.out.println("Wait等待时间：" + System.currentTimeMillis() / 1000 + " S");
                this.wait(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

结果：

![70 3][]

④：其他方法如果是static，它用的同步锁是当前类级别的，与非静态的方法不能同步，因为非静态用的锁是this。

代码：

public void mSleep() {
        synchronized (this) {
            try {
                System.out.println("Sleep当前时间：" + System.currentTimeMillis()/1000+" S");
                Thread.sleep(3000);
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void mWait() {
        synchronized (Service.class){
            try {
                System.out.println("Static Sleep Wait等待时间：" + System.currentTimeMillis() / 1000 + " S");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

结果：

![70 4][]

总结：在线程同步时，wait（）方法会让出持有锁。 sleep（）方法不会让出持有锁。

同步，要锁的类型一致。对象级别的锁 和  类级别的锁 不能混用【因为没有意义】。

[70]: /images/20210811/2131ffcf7b474058a35e1cb1f514cc51.png
[70 1]: /images/20210811/0e0e569c20614f83b9770b1fc80a6032.png
[70 2]: /images/20210811/75975f387dec448d844f9fbb812ee9c2.png
[70 3]: /images/20210811/282d0bea7ae34b76a54a913321dd4772.png
[70 4]: /images/20210811/3f23552bfe1147e5acbc616a974dde66.png